PyOpenMagnetics 1.7.5__tar.gz → 1.7.7__tar.gz

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/.github/workflows/ci.yml

@@ -17,7 +17,11 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-22.04, windows-2022, macos-14]
-        python-version: ["3.10", "3.11", "3.12"]
+        # Track every CPython that publish.yml ships a wheel for (cp310-cp314),
+        # so a version we distribute is never untested. 3.14 was added after a
+        # Windows user on 3.14 hit the sdist fallback: no cp314 wheel existed,
+        # pip tried to compile the engine with nmake and failed.
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
 
     steps:
       - uses: actions/checkout@v4

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/.github/workflows/publish.yml

@@ -26,15 +26,15 @@ jobs:
   build_and_publish_linux:
     name: Build and Publish Linux wheels (${{ matrix.python }})
     runs-on: ubuntu-22.04
-    # Each matrix job builds a single CPython version. Building all four
-    # (cp310-cp313) sequentially in one job exceeded the runner's window and
+    # Each matrix job builds a single CPython version. Building them all
+    # (cp310-cp314) sequentially in one job exceeded the runner's window and
     # was killed mid-compile (exit 143). One version per parallel job keeps
     # each job short and well under any timeout.
     timeout-minutes: 120
     strategy:
       fail-fast: false
       matrix:
-        python: [cp310, cp311, cp312, cp313]
+        python: [cp310, cp311, cp312, cp313, cp314]
     environment:
       name: pypi
       url: https://pypi.org/p/pyopenmagnetics
@@ -85,7 +85,7 @@ jobs:
           done
 
       - name: Install cibuildwheel
-        run: python -m pip install cibuildwheel==2.21.3
+        run: python -m pip install cibuildwheel==4.2.0
 
       - name: Pre-download virtualenv
         shell: bash
@@ -154,7 +154,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python: [cp310, cp311, cp312, cp313]
+        python: [cp310, cp311, cp312, cp313, cp314]
     environment:
       name: pypi
       url: https://pypi.org/p/pyopenmagnetics
@@ -197,7 +197,7 @@ jobs:
         run: npm install -g quicktype@23.2.6
 
       - name: Install cibuildwheel
-        run: python -m pip install cibuildwheel==2.21.3
+        run: python -m pip install cibuildwheel==4.2.0
 
       - name: Build wheels
         run: python -m cibuildwheel --output-dir wheelhouse
@@ -206,6 +206,17 @@ jobs:
           CIBW_SKIP: "*-win32 *-manylinux_i686 *musllinux* pp*"
           CIBW_BEFORE_ALL_WINDOWS: git config --global url."https://github.com/".insteadOf "git@github.com:" && npm install -g quicktype@23.2.6
           CIBW_BEFORE_BUILD: pip install --default-timeout=60 --retries 5 scikit-build-core "cmake<4" ninja pybind11
+          # cibuildwheel 3.0 started running `delvewheel repair` on Windows by
+          # default; 2.21.3 did no Windows repair at all. delvewheel resolves an
+          # extension's dependent DLLs via PATH, and kirchhoffapi.dll is built by
+          # the Kirchhoff ExternalProject and shipped INSIDE the package rather
+          # than installed system-wide -- so the repair aborts with "Unable to
+          # find library: kirchhoffapi.dll" and every Windows wheel fails,
+          # cp310 included. Empty = keep the behaviour that shipped every
+          # Windows wheel up to 1.7.5; scikit-build-core already places the DLL
+          # next to the extension. Bundling it via delvewheel --add-path is the
+          # follow-up, not a prerequisite for 3.14 support.
+          CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: ""
           CIBW_TEST_COMMAND: python -c "import PyOpenMagnetics; print(f'PyOpenMagnetics loaded successfully with {len(dir(PyOpenMagnetics))} functions')"
 
       - name: Install twine
@@ -234,7 +245,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python: [cp310, cp311, cp312, cp313]
+        python: [cp310, cp311, cp312, cp313, cp314]
     environment:
       name: pypi
       url: https://pypi.org/p/pyopenmagnetics
@@ -282,7 +293,7 @@ jobs:
           done
 
       - name: Install cibuildwheel
-        run: python -m pip install cibuildwheel==2.21.3
+        run: python -m pip install cibuildwheel==4.2.0
 
       - name: Build wheels
         run: python -m cibuildwheel --output-dir wheelhouse

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/CMakeLists.txt

@@ -142,7 +142,7 @@ if(NOT LOCAL_MKF_MAS)
     set(MKF_GIT_TAG "main"
         CACHE STRING "MKF git ref for the vendored PyOM build")
     # Force fresh clone by using a unique timestamp - update this when the pin changes
-    set(MKF_FORCE_REFRESH "2026-08-24-v1.7.5-mkf-25069e00")
+    set(MKF_FORCE_REFRESH "2026-08-26-mkf-10abe8d7")
     # 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/PEAS (added 2026-04 alongside the

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyOpenMagnetics
-Version: 1.7.5
+Version: 1.7.7
 Summary: Python wrapper for OpenMagnetics
 Author-Email: Alfonso Martinez <Alfonso_VII@hotmail.com>
 Classifier: Development Status :: 4 - Beta

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/pyproject.toml

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

pyopenmagnetics-1.7.7/src/common.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "pybind11_json/pybind11_json.hpp"
+#include <magic_enum.hpp>
+#include <algorithm>
+#include <stdexcept>
+#include "json.hpp"
+
+#include <MAS.hpp>
+#include "advisers/MagneticAdviser.h"
+#include "constructive_models/Bobbin.h"
+#include "constructive_models/Coil.h"
+#include "constructive_models/Core.h"
+#include "constructive_models/Insulation.h"
+#include "constructive_models/Magnetic.h"
+#include "constructive_models/Mas.h"
+#include "constructive_models/NumberTurns.h"
+#include "constructive_models/Wire.h"
+#include "physical_models/InitialPermeability.h"
+#include "physical_models/MagneticEnergy.h"
+#include "physical_models/Reluctance.h"
+#include "physical_models/Temperature.h"
+#include "physical_models/ThermalResistance.h"
+#include "physical_models/MagnetizingInductance.h"
+#include "physical_models/CoreLosses.h"
+#include "physical_models/Resistivity.h"
+#include "physical_models/CoreTemperature.h"
+#include "physical_models/LeakageInductance.h"
+#include "physical_models/Inductance.h"
+#include "physical_models/StrayCapacitance.h"
+#include "physical_models/WindingOhmicLosses.h"
+#include "physical_models/WindingSkinEffectLosses.h"
+#include "physical_models/WindingLosses.h"
+#include "processors/Inputs.h"
+#include "processors/MagneticSimulator.h"
+#include "processors/CircuitSimulatorInterface.h"
+#include "processors/Sweeper.h"
+#include "support/Painter.h"
+#include "support/Utils.h"
+
+using namespace MAS;
+using json = nlohmann::json;
+using ordered_json = nlohmann::ordered_json;
+
+namespace py = pybind11;
+
+#define STRINGIFY(x) #x
+#define MACRO_STRINGIFY(x) STRINGIFY(x)
+
+namespace PyMKF {
+
+// THE MODELS DICT NAMES THE GAP-RELUCTANCE MODEL UNDER TWO SPELLINGS, AND BOTH ARE REAL.
+// Every Python entry point here has always read "reluctance", settings.cpp publishes that key as
+// the default, and it stays the documented name. MKF's own C++ spells the same choice
+// "gapReluctance" -- CoreCrossReferencer, MagneticAdviser, MagneticFilter, MagneticFilterLosses
+// and CoreAdviserPipeline all use that -- so anyone moving between the two layers reaches for it
+// naturally. It used to be accepted and silently dropped: the key was never looked at, the call
+// fell back to defaults.reluctanceModelDefault, and a sweep over all nine models returned nine
+// identical numbers, which reads as "the model does not matter for this core" rather than "the
+// argument was ignored" (heimdall ABT #952 -- it cost a full pass of a real investigation).
+//
+// Accept both, "reluctance" first so the documented key wins if a caller somehow sets both.
+// Unknown KEYS are still ignored on purpose: one dict legitimately carries several subsystems'
+// choices ("coreLosses" alongside this one), so a strict reader would break valid callers.
+// An unknown model NAME does throw, and now says so -- magic_enum's .value() on an empty
+// optional threw a bare "bad optional access" that named neither the key nor the offending value.
+inline bool find_reluctance_model(const std::map<std::string, std::string>& models,
+                                  OpenMagnetics::ReluctanceModels& reluctanceModelName) {
+    for (const char* key : {"reluctance", "gapReluctance"}) {
+        auto entry = models.find(key);
+        if (entry == models.end()) {
+            continue;
+        }
+        std::string modelNameJsonUpper = entry->second;
+        std::transform(modelNameJsonUpper.begin(), modelNameJsonUpper.end(),
+                       modelNameJsonUpper.begin(), ::toupper);
+        auto parsed = magic_enum::enum_cast<OpenMagnetics::ReluctanceModels>(modelNameJsonUpper);
+        if (!parsed.has_value()) {
+            std::string known;
+            for (auto name : magic_enum::enum_names<OpenMagnetics::ReluctanceModels>()) {
+                known += (known.empty() ? "" : ", ") + std::string(name);
+            }
+            throw std::runtime_error("Unknown reluctance model '" + entry->second + "' given as '"
+                                     + std::string(key) + "'. Known models: " + known);
+        }
+        reluctanceModelName = parsed.value();
+        return true;
+    }
+    return false;
+}
+
+inline bool find_reluctance_model(const json& modelsData,
+                                  OpenMagnetics::ReluctanceModels& reluctanceModelName) {
+    if (modelsData.is_null() || !modelsData.is_object()) {
+        return false;
+    }
+    std::map<std::string, std::string> models;
+    for (auto& [key, value] : modelsData.items()) {
+        if (value.is_string()) {
+            models[key] = value.get<std::string>();
+        }
+    }
+    return find_reluctance_model(models, reluctanceModelName);
+}
+
+// Global database declaration - defined in module.cpp
+extern std::map<std::string, OpenMagnetics::Mas> masDatabase;
+
+// Get the directory containing the PyOpenMagnetics module
+std::string get_module_path();
+
+} // namespace PyMKF

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/src/core.cpp

@@ -290,11 +290,7 @@ double calculate_inductance_from_number_turns_and_gapping(json coreData, json co
     std::map<std::string, std::string> models = modelsData.get<std::map<std::string, std::string>>();
 
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (models.find("reluctance") != models.end()) {
-        std::string modelNameJsonUpper = models["reluctance"];
-        std::transform(modelNameJsonUpper.begin(), modelNameJsonUpper.end(), modelNameJsonUpper.begin(), ::toupper);
-        reluctanceModelName = magic_enum::enum_cast<OpenMagnetics::ReluctanceModels>(modelNameJsonUpper).value();
-    }
+    find_reluctance_model(models, reluctanceModelName);
 
     OpenMagnetics::MagnetizingInductance magnetizingInductanceObj(reluctanceModelName);
     double magnetizingInductance = magnetizingInductanceObj.calculate_inductance_from_number_turns_and_gapping(core, coil, &operatingPoint).get_magnetizing_inductance().get_nominal().value();
@@ -310,9 +306,7 @@ double calculate_number_turns_from_gapping_and_inductance(json coreData, json co
     std::map<std::string, std::string> models = modelsData.get<std::map<std::string, std::string>>();
 
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (models.find("reluctance") != models.end()) {
-        OpenMagnetics::from_json(models["reluctance"], reluctanceModelName);
-    }
+    find_reluctance_model(models, reluctanceModelName);
 
     OpenMagnetics::MagnetizingInductance magnetizingInductanceObj(reluctanceModelName);
     double numberTurns = magnetizingInductanceObj.calculate_number_turns_from_gapping_and_inductance(core, coil, &inputs);
@@ -331,9 +325,7 @@ double calculate_number_turns_from_gapping_and_inductance_legacy(json coreData,
     std::map<std::string, std::string> models = modelsData.get<std::map<std::string, std::string>>();
 
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (models.find("reluctance") != models.end()) {
-        OpenMagnetics::from_json(models["reluctance"], reluctanceModelName);
-    }
+    find_reluctance_model(models, reluctanceModelName);
 
     OpenMagnetics::MagnetizingInductance magnetizingInductanceObj(reluctanceModelName);
     double numberTurns = magnetizingInductanceObj.calculate_number_turns_from_gapping_and_inductance(core, &inputs);
@@ -351,9 +343,7 @@ json calculate_gapping_from_number_turns_and_inductance(json coreData, json coil
     OpenMagnetics::GappingType gappingType = magic_enum::enum_cast<OpenMagnetics::GappingType>(gappingTypeJson).value();
     
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (models.find("reluctance") != models.end()) {
-        OpenMagnetics::from_json(models["reluctance"], reluctanceModelName);
-    }
+    find_reluctance_model(models, reluctanceModelName);
 
     OpenMagnetics::MagnetizingInductance magnetizingInductanceObj(reluctanceModelName);
     std::vector<CoreGap> gapping = magnetizingInductanceObj.calculate_gapping_from_number_turns_and_inductance(core, coil, &inputs, gappingType, decimals);
@@ -1003,7 +993,8 @@ void register_core_bindings(py::module& m) {
             core_data: JSON object with core specification.
             coil_data: JSON object with coil specification (for turns).
             operating_point_data: JSON operating point for DC bias consideration.
-            models_data: JSON dict with "reluctance" model selection.
+            models_data: JSON dict with "reluctance" (or MKF's own spelling,
+                "gapReluctance" -- both accepted) model selection.
         
         Returns:
             Magnetizing inductance in Henries.
@@ -1021,7 +1012,8 @@ void register_core_bindings(py::module& m) {
             core_data: JSON object with core specification.
             coil_data: JSON object with coil/winding specification.
             inputs_data: JSON Inputs with magnetizingInductance requirement.
-            models_data: JSON dict with "reluctance" model selection.
+            models_data: JSON dict with "reluctance" (or MKF's own spelling,
+                "gapReluctance" -- both accepted) model selection.
 
         Returns:
             Required number of turns (may be non-integer).
@@ -1043,7 +1035,8 @@ void register_core_bindings(py::module& m) {
         Args:
             core_data: JSON object with core specification.
             inputs_data: JSON Inputs with magnetizingInductance requirement.
-            models_data: JSON dict with "reluctance" model selection.
+            models_data: JSON dict with "reluctance" (or MKF's own spelling,
+                "gapReluctance" -- both accepted) model selection.
 
         Returns:
             Required number of turns (may be non-integer).
@@ -1063,7 +1056,8 @@ void register_core_bindings(py::module& m) {
             inputs_data: JSON Inputs with magnetizingInductance requirement.
             gapping_type_json: Gap type ("SUBTRACTIVE", "ADDITIVE", "DISTRIBUTED").
             decimals: Precision in decimal places for gap length.
-            models_data: JSON dict with "reluctance" model selection.
+            models_data: JSON dict with "reluctance" (or MKF's own spelling,
+                "gapReluctance" -- both accepted) model selection.
         
         Returns:
             JSON Core object with updated gapping configuration.

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/src/losses.cpp

@@ -18,9 +18,7 @@ json calculate_core_losses(json coreData, json coilData, json inputsData, json m
     std::map<std::string, std::string> models = modelsData.get<std::map<std::string, std::string>>();
 
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (models.find("reluctance") != models.end()) {
-        OpenMagnetics::from_json(models["reluctance"], reluctanceModelName);
-    }
+    find_reluctance_model(models, reluctanceModelName);
     auto coreLossesModelName = OpenMagnetics::defaults.coreLossesModelDefault;
     if (models.find("coreLosses") != models.end()) {
         OpenMagnetics::from_json(models["coreLosses"], coreLossesModelName);
@@ -315,7 +313,7 @@ void register_losses_bindings(py::module& m) {
             inputs_data: JSON object with operating points (frequency, flux density).
             models_data: JSON dict specifying models to use:
                 - "coreLosses": "STEINMETZ", "IGSE", "MSE", "BARG", "ROSHEN", "PROPRIETARY"
-                - "reluctance": "ZHANG", "MUEHLETHALER", "PARTRIDGE", "STENGLEIN"
+                - "reluctance" (alias "gapReluctance"): "ZHANG", "MUEHLETHALER", "PARTRIDGE", "STENGLEIN"
         
         Returns:
             JSON object containing:

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/src/plotting.cpp

@@ -320,14 +320,40 @@ json plot_temperature_field(json magneticJson, json operatingPointJson, std::str
         OpenMagnetics::Magnetic magnetic(magneticJson);
         OperatingPoint operatingPoint(operatingPointJson);
 
-        OpenMagnetics::Temperature temperatureModel(magnetic);
+        // For toroidal cores, ensure the coil is wound (turn nodes need positions)
+        if (magnetic.get_core().get_shape_family() == CoreShapeFamily::T) {
+            auto coil = magnetic.get_mutable_coil();
+            if (!coil.get_turns_description() || coil.get_turns_description()->empty()) {
+                coil.wind();
+                magnetic.set_coil(coil);
+            }
+        }
+
+        double ambientTemp = operatingPoint.get_conditions().get_ambient_temperature();
+
+        // Simulate the operating point to get the losses that power the thermal
+        // network — a default-constructed Temperature(magnetic) solves an UNPOWERED
+        // network at the default 25 C ambient and paints everything stone cold
+        // (ABT #906). This mirrors the WASM wrapper in WebLibMKF.
+        OpenMagnetics::MagneticSimulator magneticSimulator;
+        OpenMagnetics::Mas mas;
+        mas.set_magnetic(magnetic);
+        mas.get_mutable_inputs().set_operating_points({operatingPoint});
+        auto simulatedMas = magneticSimulator.simulate(mas);
+        if (simulatedMas.get_outputs().empty()) {
+            throw std::runtime_error("plot_temperature_field: simulation produced no outputs");
+        }
+
+        // Shared config builder (ABT #906): the same configuration MagneticSimulator uses
+        // for outputs[].temperature, so this plot and the exported MAS can never disagree.
+        auto config = OpenMagnetics::TemperatureConfig::fromSimulatedOutput(operatingPoint, simulatedMas.get_outputs()[0]);
+
+        OpenMagnetics::Temperature temperatureModel(magnetic, config);
         auto thermalResult = temperatureModel.calculateTemperatures();
 
         std::filesystem::path filePath = outputPath.empty()
             ? std::filesystem::temp_directory_path() / "pyom_plot_temperature_field.svg"
             : std::filesystem::path(outputPath);
-
-        double ambientTemp = operatingPoint.get_conditions().get_ambient_temperature();
         OpenMagnetics::Painter painter(filePath);
         painter.paint_temperature_field(magnetic, thermalResult.nodeTemperatures, true,
             OpenMagnetics::ColorPalette::BLUE_TO_RED, ambientTemp, textColor, bgColor);

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/src/simulation.cpp

@@ -7,9 +7,7 @@ json simulate(json inputsJson, json magneticJson, json modelsData) {
     OpenMagnetics::Magnetic magnetic(magneticJson);
     
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (!modelsData.is_null() && modelsData.find("reluctance") != modelsData.end()) {
-        OpenMagnetics::from_json(modelsData["reluctance"], reluctanceModelName);
-    }
+    find_reluctance_model(modelsData, reluctanceModelName);
     auto coreLossesModelName = OpenMagnetics::defaults.coreLossesModelDefault;
     if (!modelsData.is_null() && modelsData.find("coreLosses") != modelsData.end()) {
         OpenMagnetics::from_json(modelsData["coreLosses"], coreLossesModelName);
@@ -145,9 +143,7 @@ json calculate_inductance_matrix(json magneticJson, double frequency, json model
     OpenMagnetics::Magnetic magnetic(magneticJson);
     
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (!modelsData.is_null() && modelsData.find("reluctance") != modelsData.end()) {
-        OpenMagnetics::from_json(modelsData["reluctance"], reluctanceModelName);
-    }
+    find_reluctance_model(modelsData, reluctanceModelName);
 
     OpenMagnetics::Inductance inductance(reluctanceModelName);
     auto inductanceMatrix = inductance.calculate_inductance_matrix(magnetic, frequency);
@@ -313,9 +309,7 @@ json calculate_coupling_coefficient_matrix(json magneticJson, double frequency,
     OpenMagnetics::Magnetic magnetic(magneticJson);
 
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (!modelsData.is_null() && modelsData.find("reluctance") != modelsData.end()) {
-        OpenMagnetics::from_json(modelsData["reluctance"], reluctanceModelName);
-    }
+    find_reluctance_model(modelsData, reluctanceModelName);
 
     OpenMagnetics::Inductance inductance(reluctanceModelName);
 
@@ -352,9 +346,7 @@ json calculate_leakage_inductance_matrix(json magneticJson, double frequency, js
     OpenMagnetics::Magnetic magnetic(magneticJson);
 
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
-    if (!modelsData.is_null() && modelsData.find("reluctance") != modelsData.end()) {
-        OpenMagnetics::from_json(modelsData["reluctance"], reluctanceModelName);
-    }
+    find_reluctance_model(modelsData, reluctanceModelName);
 
     OpenMagnetics::Inductance inductance(reluctanceModelName);
     auto leakageInductanceMatrix = inductance.calculate_leakage_inductance_matrix(magnetic, frequency);

{pyopenmagnetics-1.7.5 → pyopenmagnetics-1.7.7}/src/winding.cpp

@@ -117,7 +117,14 @@ json wind(json coilJson, size_t repetitions, json proportionPerWindingJson, json
     }
 
     if (!coil.get_turns_description()) {
-        throw std::runtime_error("Turns not created");
+        // ABT #930: "Turns not created" on its own cannot be acted on — it reads as a broken
+        // winder even when MKF is correctly refusing an impossible geometry (a 0.36 mm conductor
+        // asked into a 0.10 mm annulus). MKF now records why; pass it on.
+        const auto& reason = coil.get_last_fit_failure();
+        throw std::runtime_error(reason.empty()
+            ? std::string("Turns not created: the winding does not fit its window, and the reason "
+                          "could not be narrowed further.")
+            : "Turns not created. " + reason);
     }
 
     json result;
@@ -136,7 +143,12 @@ json wind_planar(json coilJson, json stackUpJson, double borderToWireDistance, j
     coil.wind_planar(stackUp, borderToWireDistance, wireToWireDistance, insulationThickness, coreToLayerDistance);
 
     if (!coil.get_turns_description()) {
-        throw std::runtime_error("Turns not created");
+        // ABT #930: same as wind() above — say why, not just that.
+        const auto& reason = coil.get_last_fit_failure();
+        throw std::runtime_error(reason.empty()
+            ? std::string("Turns not created: the planar winding does not fit its window, and the "
+                          "reason could not be narrowed further.")
+            : "Turns not created. " + reason);
     }
 
     return coil;

pyopenmagnetics-1.7.5/src/common.h

@@ -1,58 +0,0 @@
-#pragma once
-
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include "pybind11_json/pybind11_json.hpp"
-#include <magic_enum.hpp>
-#include "json.hpp"
-
-#include <MAS.hpp>
-#include "advisers/MagneticAdviser.h"
-#include "constructive_models/Bobbin.h"
-#include "constructive_models/Coil.h"
-#include "constructive_models/Core.h"
-#include "constructive_models/Insulation.h"
-#include "constructive_models/Magnetic.h"
-#include "constructive_models/Mas.h"
-#include "constructive_models/NumberTurns.h"
-#include "constructive_models/Wire.h"
-#include "physical_models/InitialPermeability.h"
-#include "physical_models/MagneticEnergy.h"
-#include "physical_models/Reluctance.h"
-#include "physical_models/Temperature.h"
-#include "physical_models/ThermalResistance.h"
-#include "physical_models/MagnetizingInductance.h"
-#include "physical_models/CoreLosses.h"
-#include "physical_models/Resistivity.h"
-#include "physical_models/CoreTemperature.h"
-#include "physical_models/LeakageInductance.h"
-#include "physical_models/Inductance.h"
-#include "physical_models/StrayCapacitance.h"
-#include "physical_models/WindingOhmicLosses.h"
-#include "physical_models/WindingSkinEffectLosses.h"
-#include "physical_models/WindingLosses.h"
-#include "processors/Inputs.h"
-#include "processors/MagneticSimulator.h"
-#include "processors/CircuitSimulatorInterface.h"
-#include "processors/Sweeper.h"
-#include "support/Painter.h"
-#include "support/Utils.h"
-
-using namespace MAS;
-using json = nlohmann::json;
-using ordered_json = nlohmann::ordered_json;
-
-namespace py = pybind11;
-
-#define STRINGIFY(x) #x
-#define MACRO_STRINGIFY(x) STRINGIFY(x)
-
-namespace PyMKF {
-
-// Global database declaration - defined in module.cpp
-extern std::map<std::string, OpenMagnetics::Mas> masDatabase;
-
-// Get the directory containing the PyOpenMagnetics module
-std::string get_module_path();
-
-} // namespace PyMKF