PyOpenMagnetics 1.7.22__tar.gz → 1.7.24__tar.gz

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/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-09-06-mkf-f5fc2563")
+    set(MKF_FORCE_REFRESH "2026-09-28-mkf-780d21de")
     # 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.22 → pyopenmagnetics-1.7.24}/PKG-INFO

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

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/PyOpenMagnetics.pyi

@@ -512,6 +512,18 @@ def get_core_losses_model_information(material: CoreMaterial) -> JsonDict:
     """Get available loss models and data for material."""
     ...
 
+def validate_material(material: CoreMaterial, extra_loss_points: List[JsonDict] = ...) -> JsonDict:
+    """Magnetic Blade Runner: physics check of one MAS core-material record.
+
+    Returns {reference, valid, materialClass, findings, skipped}; valid is False iff a finding
+    is IMPOSSIBLE.
+    """
+    ...
+
+def validate_all_materials(core_materials_path: str = "", advanced_core_materials_path: str = "") -> JsonDict:
+    """Magnetic Blade Runner over a core-material catalogue (empty path = MKF's embedded one)."""
+    ...
+
 # =============================================================================
 # WINDING ENGINE
 # =============================================================================

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/pyproject.toml

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

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/src/losses.cpp

@@ -1,4 +1,5 @@
 #include "losses.h"
+#include "support/MaterialValidator.h"
 
 namespace PyMKF {
 
@@ -59,6 +60,35 @@ json get_core_losses_model_information(json material) {
     return info;
 }
 
+json validate_material(json material, json extraLossPoints) {
+    std::vector<OpenMagnetics::MaterialLossPoint> points;
+    for (const auto& p : extraLossPoints) {
+        points.push_back(OpenMagnetics::MaterialLossPoint{p.at("frequency").get<double>(), p.at("magneticFluxDensityPeak").get<double>(),
+                                                          p.at("temperature").get<double>(), p.at("volumetricLosses").get<double>(),
+                                                          p.value("origin", std::string())});
+    }
+    json out = OpenMagnetics::MaterialValidator().validate(material, points);
+    return out;
+}
+
+json validate_all_materials(std::string coreMaterialsPath, std::string advancedCoreMaterialsPath) {
+    OpenMagnetics::MaterialValidator validator;
+    std::vector<OpenMagnetics::MaterialVerdict> verdicts;
+    if (coreMaterialsPath.empty()) {
+        if (!advancedCoreMaterialsPath.empty()) {
+            throw std::invalid_argument("advanced_core_materials_path needs core_materials_path");
+        }
+        verdicts = validator.validate_embedded_catalogue();
+    }
+    else {
+        verdicts = validator.validate_catalogue(coreMaterialsPath, advancedCoreMaterialsPath.empty() ? std::nullopt : std::optional<std::string>(advancedCoreMaterialsPath));
+    }
+    json out = OpenMagnetics::summarize_material_verdicts(verdicts);
+    out["verdicts"] = verdicts;
+    out["classTable"] = OpenMagnetics::MaterialValidator::class_table_json();
+    return out;
+}
+
 json calculate_steinmetz_coefficients(json dataJson, json rangesJson) {
     std::vector<std::pair<double, double>> ranges;
     for (auto rangeJson : rangesJson) {
@@ -334,6 +364,42 @@ void register_losses_bindings(py::module& m) {
         py::arg("core_data"), py::arg("coil_data"), py::arg("inputs_data"), py::arg("models_data"),
         py::call_guard<py::gil_scoped_release>());
     
+    m.def("validate_material", &validate_material,
+        R"pbdoc(
+        Magnetic Blade Runner: check one MAS core-material record against physics.
+
+        Evaluates the record with MKF's own loss/permeability/saturation models and judges the
+        results against published class envelopes (each with its datasheet source).
+
+        Args:
+            material: one MAS core-material record (a line of core_materials.ndjson).
+            extra_loss_points: optional measured points kept outside the record, each
+                {frequency, magneticFluxDensityPeak, temperature, volumetricLosses, origin}.
+
+        Returns:
+            {reference, valid, materialClass, findings: [{code, severity (WARNING/SUSPICIOUS/
+            IMPOSSIBLE), component, reference, message, value, threshold}], skipped: ["RULE: reason"]}.
+            valid is False iff a finding is IMPOSSIBLE.
+        )pbdoc",
+        py::arg("material"), py::arg("extra_loss_points") = json::array(),
+        py::call_guard<py::gil_scoped_release>());
+
+    m.def("validate_all_materials", &validate_all_materials,
+        R"pbdoc(
+        Magnetic Blade Runner over a whole core-material catalogue.
+
+        Args:
+            core_materials_path: a core_materials.ndjson; empty = the catalogue built into MKF.
+            advanced_core_materials_path: optional advanced_core_materials.ndjson (real file,
+                not a git-LFS pointer) whose sinusoidal loss points are checked too.
+
+        Returns:
+            Summary {records, invalid, recordsWithSuspicious, unclassified, findingsByCode,
+            skippedByCode, provenance, impossible, suspicious} plus verdicts and classTable.
+        )pbdoc",
+        py::arg("core_materials_path") = "", py::arg("advanced_core_materials_path") = "",
+        py::call_guard<py::gil_scoped_release>());
+
     m.def("get_core_losses_model_information", &get_core_losses_model_information,
         R"pbdoc(
         Get documentation and metadata for available core loss models.

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/src/losses.h

@@ -7,6 +7,10 @@ namespace PyMKF {
 // Core losses
 json calculate_core_losses(json coreData, json coilData, json inputsData, json modelsData);
 json get_core_losses_model_information(json material);
+
+// Magnetic Blade Runner: physics validation of MAS core-material records
+json validate_material(json material, json extraLossPoints);
+json validate_all_materials(std::string coreMaterialsPath, std::string advancedCoreMaterialsPath);
 json calculate_steinmetz_coefficients(json dataJson, json rangesJson);
 json calculate_steinmetz_coefficients_with_error(json dataJson, json rangesJson);
 

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/src/settings.cpp

@@ -193,6 +193,9 @@ json get_settings() {
     // Memory kept for the turn-field sums of recently evaluated meshes (0 keeps nothing).
     settingsJson["magneticFieldTurnSumsCacheBytes"] = OpenMagnetics::settings.get_magnetic_field_turn_sums_cache_bytes();
 
+    // Thermal network: a turn overlapping its enclosure throws (true) or loses that conduction path with an ERROR logged (false).
+    settingsJson["thermalNetworkStrictGeometry"] = OpenMagnetics::settings.get_thermal_network_strict_geometry();
+
     // Models
     {
         json aux;
@@ -379,6 +382,9 @@ void set_settings(json settingsJson) {
     if (settingsJson.contains("harmonicAmplitudeThreshold")) OpenMagnetics::settings.set_harmonic_amplitude_threshold(settingsJson["harmonicAmplitudeThreshold"]);
     if (settingsJson.contains("magneticFieldTurnSumsCacheBytes")) OpenMagnetics::settings.set_magnetic_field_turn_sums_cache_bytes(settingsJson["magneticFieldTurnSumsCacheBytes"].get<size_t>());
 
+    // Thermal network
+    if (settingsJson.contains("thermalNetworkStrictGeometry")) OpenMagnetics::settings.set_thermal_network_strict_geometry(settingsJson["thermalNetworkStrictGeometry"]);
+
     // Models
     if (settingsJson.contains("magneticFieldStrengthModel")) {
         OpenMagnetics::MagneticFieldStrengthModels model;

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/src/simulation.cpp

@@ -23,6 +23,31 @@ json simulate(json inputsJson, json magneticJson, json modelsData) {
     return result;
 }
 
+json build_datasheet(json inputsJson, json magneticJson, json modelsData) {
+    // Simulate the magnetic at the given operating points (the same models as simulate), then let
+    // MagneticSimulator::build_datasheet read the outputs into a manufacturer-style datasheet. Returns
+    // the magnetic's manufacturerInfo with datasheetInfo filled in; its other fields are kept.
+    OpenMagnetics::Inputs inputs(inputsJson);
+    OpenMagnetics::Magnetic magnetic(magneticJson);
+
+    auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
+    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);
+    }
+
+    OpenMagnetics::MagneticSimulator magneticSimulator;
+    magneticSimulator.set_core_losses_model_name(coreLossesModelName);
+    magneticSimulator.set_reluctance_model_name(reluctanceModelName);
+    auto mas = magneticSimulator.simulate(inputs, magnetic);
+    auto manufacturerInfo = magneticSimulator.build_datasheet(mas);
+
+    json result;
+    to_json(result, manufacturerInfo);
+    return result;
+}
+
 std::string export_magnetic_as_subcircuit(json magneticJson) {
     // Returns the raw SPICE subcircuit netlist as a plain string. We must NOT
     // return nlohmann::ordered_json here: pybind11_json registers a caster for
@@ -418,6 +443,27 @@ void register_simulation_bindings(py::module& m) {
         )pbdoc",
         py::call_guard<py::gil_scoped_release>());
     
+    m.def("build_datasheet", &build_datasheet,
+        R"pbdoc(
+        Build a manufacturer-style datasheet for a magnetic from MKF's own simulation.
+
+        Simulates the magnetic at the given operating points, then reads the results into
+        manufacturerInfo.datasheetInfo (MagneticSimulator::build_datasheet): inductance at the
+        first operating point, DC resistance, the heat-limited rated current (40 K rise), the
+        peak saturation current at the hottest operating point, self-resonant frequency and an
+        impedance sweep, thermal and mechanical data.
+
+        Args:
+            inputs_json: MAS Inputs: the conditions the datasheet is stated at.
+            magnetic_json: the magnetic (core and coil).
+            models_json: models to simulate with, as for simulate().
+
+        Returns:
+            The magnetic's manufacturerInfo with datasheetInfo filled in.
+        )pbdoc",
+        py::arg("inputs_json"), py::arg("magnetic_json"), py::arg("models_json"),
+        py::call_guard<py::gil_scoped_release>());
+
     m.def("export_magnetic_as_subcircuit", &export_magnetic_as_subcircuit,
         R"pbdoc(
         Export a magnetic component as a SPICE-compatible subcircuit.

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/src/simulation.h

@@ -6,6 +6,7 @@ namespace PyMKF {
 
 // Simulation
 json simulate(json inputsJson, json magneticJson, json modelsData);
+json build_datasheet(json inputsJson, json magneticJson, json modelsData);
 
 // Export
 std::string export_magnetic_as_subcircuit(json magneticJson);

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/tests/test_datasheet_only_catalogue.py

@@ -142,3 +142,18 @@ def test_results_can_come_back_ranked_but_unsimulated(mixed_catalogue):
     built = references_of(simulated).index("BUILT")
     assert simulated["data"][built]["mas"].get("outputs"), "the default still simulates a modelled part"
     assert not ranked["data"][built]["mas"].get("outputs")
+
+
+def test_build_datasheet_states_what_mkf_simulates_for_a_modelled_part():
+    """A modelled part with no datasheet gets one from MKF: the values a catalogue datasheet
+    states, computed at the given conditions, with the part's own manufacturerInfo kept."""
+    part = modelled_part("BUILT")
+    del part["manufacturerInfo"]["datasheetInfo"]
+    info = PyOpenMagnetics.build_datasheet(buck_inputs(), PyOpenMagnetics.magnetic_autocomplete(part, {}), {})
+
+    assert info["reference"] == "BUILT"
+    electrical = info["datasheetInfo"]["electrical"][0]
+    assert electrical["subtype"] == "inductor"
+    for key in ("inductance", "dcResistance", "ratedCurrents", "saturationCurrentPeak", "selfResonantFrequency"):
+        assert electrical.get(key) is not None, key
+    assert electrical["ratedCurrents"][0] > 0 and electrical["saturationCurrentPeak"] > 0

{pyopenmagnetics-1.7.22 → pyopenmagnetics-1.7.24}/tests/test_examples_integration.py

@@ -171,6 +171,22 @@ class TestSettingsManagement:
         assert after_reset is not None
         assert isinstance(after_reset, dict)
 
+    def test_thermal_network_strict_geometry_round_trip(self):
+        """thermalNetworkStrictGeometry defaults to strict and round-trips through set_settings."""
+        PyOpenMagnetics.reset_settings()
+        try:
+            assert PyOpenMagnetics.get_settings()["thermalNetworkStrictGeometry"] is True
+
+            settings = PyOpenMagnetics.get_settings()
+            settings["thermalNetworkStrictGeometry"] = False
+            PyOpenMagnetics.set_settings(settings)
+            assert PyOpenMagnetics.get_settings()["thermalNetworkStrictGeometry"] is False
+
+            PyOpenMagnetics.reset_settings()
+            assert PyOpenMagnetics.get_settings()["thermalNetworkStrictGeometry"] is True
+        finally:
+            PyOpenMagnetics.reset_settings()
+
 
 class TestBobbinCreation:
     """Test bobbin creation for cores."""

pyopenmagnetics-1.7.24/tests/test_material_validator.py

@@ -0,0 +1,40 @@
+"""Magnetic Blade Runner (MKF MaterialValidator) through the Python binding."""
+import copy
+
+import pytest
+import PyOpenMagnetics
+
+
+def _material(name):
+    return PyOpenMagnetics.get_material_data(name)
+
+
+def test_real_power_ferrite_is_clean():
+    verdict = PyOpenMagnetics.validate_material(_material("N87"))
+    assert verdict["valid"] is True
+    assert verdict["findings"] == []
+    assert verdict["materialClass"] == "MnZn power ferrite"
+
+
+def test_saturation_above_iron_is_impossible():
+    record = copy.deepcopy(_material("N87"))
+    record["name"] = "N87 Bs 3 T"
+    record["saturation"][0]["magneticFluxDensity"] = 3.0
+    verdict = PyOpenMagnetics.validate_material(record)
+    assert verdict["valid"] is False
+    assert any(f["code"] == "MAT_BSAT_CEILING" and f["severity"] == "IMPOSSIBLE" for f in verdict["findings"])
+
+
+def test_extra_points_hysteresis_bound():
+    points = [{"frequency": 1e3, "magneticFluxDensityPeak": 0.05, "temperature": 25,
+               "volumetricLosses": 80e3, "origin": "manufacturer"}]
+    verdict = PyOpenMagnetics.validate_material(_material("P63"), points)
+    assert any(f["code"] == "MAT_LOSS_HYSTERESIS_BOUND" for f in verdict["findings"])
+
+
+def test_embedded_catalogue_sweep():
+    summary = PyOpenMagnetics.validate_all_materials()
+    assert summary["records"] > 1000
+    assert len(summary["verdicts"]) == summary["records"]
+    assert "findingsByCode" in summary
+    assert len(summary["classTable"]) > 0