PyOpenMagnetics 1.7.35__tar.gz → 1.7.37__tar.gz

{pyopenmagnetics-1.7.35 → pyopenmagnetics-1.7.37}/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-10-04-mkf-39b59172")
+    set(MKF_FORCE_REFRESH "2026-10-28-mkf-292dd4c2")
     # 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
@@ -430,6 +430,20 @@ file(GLOB SOURCES src/*.cpp
     ${MKF_DIR}/src/support/*.cpp
     )
 
+# MKF parses its MAS databases with simdjson (src/support/FastJsonParse.cpp), compiled from the single-header
+# amalgamation as in MKF's own CMakeLists.txt; only those two files see its header.
+if(EXISTS "${MKF_DIR}/src/support/FastJsonParse.cpp")
+    FetchContent_Declare(simdjson
+        GIT_REPOSITORY https://github.com/simdjson/simdjson.git
+        GIT_TAG  tags/v5.0.5
+        GIT_SHALLOW TRUE
+        SOURCE_SUBDIR singleheader-not-a-cmake-project)
+    FetchContent_MakeAvailable(simdjson)
+    list(APPEND SOURCES "${simdjson_SOURCE_DIR}/singleheader/simdjson.cpp")
+    set_source_files_properties("${simdjson_SOURCE_DIR}/singleheader/simdjson.cpp" "${MKF_DIR}/src/support/FastJsonParse.cpp"
+        PROPERTIES INCLUDE_DIRECTORIES "${simdjson_SOURCE_DIR}/singleheader")
+endif()
+
 # converter.cpp is now a thin shim over the Kirchhoff string API (libKirchhoffApi) — re-enabled.
 
 set(CCI_GENERATED_CPP "${CMAKE_BINARY_DIR}/generated/CciCoordinatesData.cpp")

{pyopenmagnetics-1.7.35 → pyopenmagnetics-1.7.37}/PKG-INFO

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

{pyopenmagnetics-1.7.35 → pyopenmagnetics-1.7.37}/pyproject.toml

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

{pyopenmagnetics-1.7.35 → pyopenmagnetics-1.7.37}/src/core.cpp

@@ -1,6 +1,7 @@
 #include "core.h"
 #include "constructive_models/CorePiece.h"
 #include "physical_models/ComplexPermeability.h"
+#include "Defaults.h"
 #include <filesystem>
 
 namespace PyMKF {
@@ -284,7 +285,8 @@ json calculate_gap_reluctance(json coreGapData, std::string modelNameString) {
     auto reluctanceModel = OpenMagnetics::ReluctanceModel::factory(modelName);
     CoreGap coreGap(coreGapData);
 
-    auto coreGapResult = reluctanceModel->get_gap_reluctance(coreGap);
+    // A standalone gap: no core material, so its storable energy is at the default reference flux density.
+    auto coreGapResult = reluctanceModel->get_gap_reluctance(coreGap, OpenMagnetics::Defaults().gapReluctanceEnergyFluxDensity);
     json result;
     to_json(result, coreGapResult);
     return result;
@@ -445,13 +447,16 @@ double calculate_peak_winding_current(json magneticJson, json operatingPointJson
     }
 
     // The magnetizing (flux-driving) current is referred to the primary
-    // (winding 0): I_mag = (1/L) ∫ v_primary dt, derived from the primary
-    // excitation's voltage. addOffset=true folds the operating DC bias of
-    // the primary current back in, so the returned peak is the saturation-
-    // driving peak (DC + ripple), not just the AC ripple amplitude.
-    auto primaryExcitation = excitations[0];
+    // (winding 0): Faraday on the primary voltage, I_mag = (1/L) ∫ v dt,
+    // plus the DC the winding currents give (a single winding's own current,
+    // or the anchor of windings that do not always conduct together: a
+    // flyback, a forward's reset). This is MKF's one shared decision
+    // (Inputs::calculate_magnetizing_current on the operating point), so the
+    // returned peak is the saturation-driving peak (DC + ripple). The former
+    // call passed `true` into the dcCurrent slot, which C++ converted to a
+    // flat 1 A DC whatever the currents were.
     auto magnetizingCurrent = OpenMagnetics::Inputs::calculate_magnetizing_current(
-        primaryExcitation, magnetizingInductance, true, true);
+        op, 0, magnetizingInductance, magnetic.get_mutable_coil().get_turns_ratios(), true);
     auto processed = magnetizingCurrent.get_processed();
     if (!processed.has_value() || !processed->get_peak().has_value()) {
         throw std::runtime_error(

{pyopenmagnetics-1.7.35 → pyopenmagnetics-1.7.37}/src/losses.cpp

@@ -32,7 +32,11 @@ json calculate_core_losses(json coreData, json coilData, json inputsData, json m
     OpenMagnetics::MagneticSimulator magneticSimulator;
     magneticSimulator.set_core_losses_model_name(coreLossesModelName);
     magneticSimulator.set_reluctance_model_name(reluctanceModelName);
-    auto coreLossesOutput = magneticSimulator.calculate_core_losses(operatingPoint, magnetic);
+    // ABT #1876 (Alf, 2026-10-14): a point with no thermal operating point gets its core losses at ambient and
+    // NO temperature (temperatureOutput stays empty); its coreLosses.temperature is the ambient they were
+    // evaluated at, not an operating temperature.
+    std::optional<TemperatureOutput> temperatureOutput;
+    auto coreLossesOutput = magneticSimulator.calculate_core_losses(operatingPoint, magnetic, nullptr, &temperatureOutput);
     json result;
     to_json(result, coreLossesOutput);
 
@@ -44,8 +48,12 @@ json calculate_core_losses(json coreData, json coilData, json inputsData, json m
     result["voltageRms"] = operatingPoint.get_mutable_excitations_per_winding()[0].get_voltage().value().get_processed().value().get_rms().value();
     result["currentRms"] = operatingPoint.get_mutable_excitations_per_winding()[0].get_current().value().get_processed().value().get_rms().value();
     result["apparentPower"] = operatingPoint.get_mutable_excitations_per_winding()[0].get_voltage().value().get_processed().value().get_rms().value() * operatingPoint.get_mutable_excitations_per_winding()[0].get_current().value().get_processed().value().get_rms().value();
-    result["maximumCoreTemperature"] = coreLossesOutput.get_temperature();
-    result["maximumCoreTemperatureRise"] = coreLossesOutput.get_temperature() - operatingPoint.get_conditions().get_ambient_temperature();
+    // The core temperature the losses were solved at, only when the point has a thermal operating point:
+    // otherwise both keys are absent.
+    if (temperatureOutput) {
+        result["maximumCoreTemperature"] = coreLossesOutput.get_temperature();
+        result["maximumCoreTemperatureRise"] = coreLossesOutput.get_temperature() - operatingPoint.get_conditions().get_ambient_temperature();
+    }
 
     return result;
 }
@@ -353,8 +361,10 @@ void register_losses_bindings(py::module& m) {
                 - voltageRms: RMS voltage in Volts
                 - currentRms: RMS current in Amperes
                 - apparentPower: Apparent power in VA
-                - maximumCoreTemperature: Estimated max temperature in Celsius
-                - maximumCoreTemperatureRise: Temperature rise in Kelvin
+                - maximumCoreTemperature: Core temperature the losses were solved at, in Celsius.
+                  Absent when the point has no thermal operating point (the losses are then
+                  those at ambient; analyze_results reports NO_THERMAL_OPERATING_POINT).
+                - maximumCoreTemperatureRise: Temperature rise in Kelvin; absent likewise.
         
         Example:
             >>> models = {"coreLosses": "IGSE", "reluctance": "ZHANG"}

{pyopenmagnetics-1.7.35 → pyopenmagnetics-1.7.37}/src/simulation.cpp

@@ -1,4 +1,5 @@
 #include "simulation.h"
+#include "processors/ResultsAnalyzer.h"
 
 namespace PyMKF {
 
@@ -23,6 +24,14 @@ json simulate(json inputsJson, json magneticJson, json modelsData) {
     return result;
 }
 
+json analyze_results(json masJson) {
+    OpenMagnetics::Mas mas(masJson);
+    auto findings = OpenMagnetics::ResultsAnalyzer::analyze_results(mas);
+    json result;
+    OpenMagnetics::to_json(result, findings);
+    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
@@ -312,10 +321,30 @@ json sweep_magnetizing_inductance_over_dc_bias(json magneticJson, double start,
     return resultJson;
 }
 
-json sweep_core_losses_over_frequency(json magneticJson, json operatingPointJson, double start, double stop, size_t numberElements, double temperature, std::string mode, std::string title) {
+// The generated from_json leaves a Topology untouched for a name it does not know, so an unknown
+// name would reach the model as an uninitialised value: match it against each topology's own
+// spelling and throw when none matches.
+static std::optional<MAS::Topology> parse_optional_topology(const json& topologyJson) {
+    if (topologyJson.is_null()) {
+        return std::nullopt;
+    }
+    for (auto candidate : magic_enum::enum_values<MAS::Topology>()) {
+        json spelling;
+        to_json(spelling, candidate);
+        if (spelling == topologyJson) {
+            return candidate;
+        }
+    }
+    throw std::invalid_argument("Unknown topology " + topologyJson.dump());
+}
+
+// topologyJson: the design's designRequirements.topology, None when the design has none. The
+// magnetizing current that drives the core depends on it (MKF ABT #1754).
+json sweep_core_losses_over_frequency(json magneticJson, json operatingPointJson, json topologyJson, double start, double stop, size_t numberElements, double temperature, std::string mode, std::string title) {
     OpenMagnetics::Magnetic magnetic(magneticJson);
     OperatingPoint operatingPoint(operatingPointJson);
-    auto result = OpenMagnetics::Sweeper::sweep_core_losses_over_frequency(magnetic, operatingPoint, start, stop, numberElements, temperature, mode, title);
+    auto topology = parse_optional_topology(topologyJson);
+    auto result = OpenMagnetics::Sweeper::sweep_core_losses_over_frequency(magnetic, operatingPoint, topology, start, stop, numberElements, temperature, mode, title);
     json resultJson;
     to_json(resultJson, result);
     return resultJson;
@@ -443,6 +472,25 @@ void register_simulation_bindings(py::module& m) {
         )pbdoc",
         py::call_guard<py::gil_scoped_release>());
     
+    m.def("analyze_results", &analyze_results,
+        R"pbdoc(
+        MKF's findings on a simulated MAS (ABT #1855).
+
+        simulate gives its numbers for every operating point and does not judge them; this says
+        whether they describe a part that works: a saturating core, a voltage that is not
+        volt-second balanced (simulated on its balanced part), a core or winding above a
+        temperature limit its part states (or a part that states none), a core driven past the
+        temperatures its material data covers.
+
+        Args:
+            mas_json: a simulated MAS, with one output per operating point.
+
+        Returns:
+            JSON array of {operatingPointIndex, operatingPointName (when the point has one),
+            code, message}. Raises when the MAS lacks an output for an operating point.
+        )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.
@@ -776,13 +824,14 @@ void register_simulation_bindings(py::module& m) {
     m.def("sweep_core_losses_over_frequency", &sweep_core_losses_over_frequency,
         py::arg("magnetic_json"),
         py::arg("operating_point_json"),
+        py::arg("topology"),
         py::arg("start"),
         py::arg("stop"),
         py::arg("number_elements"),
         py::arg("temperature"),
         py::arg("mode"),
         py::arg("title"),
-        "Sweep core losses over a frequency range.",
+        "Sweep core losses over a frequency range. topology: the design's designRequirements.topology, None when it has none.",
         py::call_guard<py::gil_scoped_release>());
 
     m.def("sweep_winding_losses_over_frequency", &sweep_winding_losses_over_frequency,

{pyopenmagnetics-1.7.35 → pyopenmagnetics-1.7.37}/src/simulation.h

@@ -6,6 +6,9 @@ namespace PyMKF {
 
 // Simulation
 json simulate(json inputsJson, json magneticJson, json modelsData);
+// ABT #1855: MKF's findings on a simulated MAS (one output per operating point), each naming its
+// operating point: a JSON array of {operatingPointIndex, operatingPointName?, code, message}.
+json analyze_results(json masJson);
 json build_datasheet(json inputsJson, json magneticJson, json modelsData);
 
 // Export
@@ -44,7 +47,7 @@ json sweep_resistance_over_frequency(json magneticJson, double start, double sto
 json sweep_magnetizing_inductance_over_frequency(json magneticJson, double start, double stop, size_t numberElements, double temperature, std::string mode, std::string title);
 json sweep_magnetizing_inductance_over_temperature(json magneticJson, double start, double stop, size_t numberElements, double frequency, std::string mode, std::string title);
 json sweep_magnetizing_inductance_over_dc_bias(json magneticJson, double start, double stop, size_t numberElements, double temperature, std::string mode, std::string title);
-json sweep_core_losses_over_frequency(json magneticJson, json operatingPointJson, double start, double stop, size_t numberElements, double temperature, std::string mode, std::string title);
+json sweep_core_losses_over_frequency(json magneticJson, json operatingPointJson, json topologyJson, double start, double stop, size_t numberElements, double temperature, std::string mode, std::string title);
 json sweep_winding_losses_over_frequency(json magneticJson, json operatingPointJson, double start, double stop, size_t numberElements, double temperature, std::string mode, std::string title);
 
 // Matrix calculations

{pyopenmagnetics-1.7.35 → pyopenmagnetics-1.7.37}/tests/test_core.py

@@ -4,6 +4,7 @@ Tests for PyOpenMagnetics Core data retrieval and calculations.
 These tests mirror TestCore.cpp and TestCoreAdviser.cpp from MKF,
 verifying core shape, material, and gapping calculations.
 """
+import math
 import pytest
 import PyOpenMagnetics
 
@@ -245,6 +246,42 @@ class TestPeakWindingCurrent:
             magnetic, op_used, 25.0)
         assert isat > ipeak  # an advised design should not be saturating
 
+    def test_flyback_peak_is_the_primary_current_peak(self):
+        """
+        A CCM flyback, 1:1, 100 kHz, D = 0.5: the primary carries 2 -> 6 A
+        during the on-time, the secondary 6 -> 2 A during the off-time. Each
+        winding alone carries the magnetizing MMF while it conducts, so the
+        magnetizing current peaks at the primary current's peak, 6 A (MKF's
+        shared magnetizing-current decision, DC anchored where the primary
+        conducts alone). The binding used to pass `true` into MKF's dcCurrent
+        argument: a flat 1 A DC under a zero-mean Faraday ripple, ~3 A.
+        """
+        def winding(name, current, voltage):
+            return {
+                "name": name,
+                "frequency": 100000,
+                "current": {"waveform": {"data": current,
+                                         "time": [0, 0.000005, 0.000005, 0.00001]}},
+                "voltage": {"waveform": {"data": voltage,
+                                         "time": [0, 0.000005, 0.000005, 0.00001]}},
+            }
+        op = {
+            "name": "Nominal",
+            "conditions": {"ambientTemperature": 25},
+            "excitationsPerWinding": [
+                winding("Primary", [2, 6, 0, 0], [80, 80, -80, -80]),
+                winding("Secondary", [0, 0, 6, 2], [-80, -80, 80, 80]),
+            ],
+        }
+        inputs = {
+            "designRequirements": {"magnetizingInductance": {"nominal": 100e-6},
+                                   "turnsRatios": [{"nominal": 1.0}]},
+            "operatingPoints": [op],
+        }
+        magnetic, op_used = self._advise_magnetic(inputs)
+        ipeak = PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used, 0)
+        assert ipeak == pytest.approx(6.0, rel=0.05)
+
     def test_transformer_winding_index_scales_by_turns_ratio(self):
         """
         For a transformer the per-winding magnetizing peak is the primary
@@ -324,11 +361,20 @@ class TestComplexPermeabilityFrequencyRange:
         # A07's tabulated mu''(f) ends at ~17 MHz (mu' extended to it by Kramers-Kronig in MAS).
         assert 1e7 < span["maximum"] < 1e8
 
-    def test_inside_the_span_answers_and_outside_it_throws(self):
+    def test_inside_the_span_answers_and_above_it_estimates(self):
+        # MKF ABT #1861: outside the tabulated span the complex permeability of a material the
+        # estimator covers is answered with the approved estimate, no longer thrown
+        # (MATERIAL_FREQUENCY_OUT_OF_SPAN). Inside the span the table answers, as before.
         material = PyOpenMagnetics.find_core_material_by_name("A07")
         span = PyOpenMagnetics.calculate_complex_permeability_frequency_range(material)
         assert span == PyOpenMagnetics.calculate_complex_permeability_frequency_range("A07")
         inside = PyOpenMagnetics.calculate_complex_permeability(material, span["maximum"] * 0.99)
         assert inside["imaginary"] > 0
-        with pytest.raises(Exception):
-            PyOpenMagnetics.calculate_complex_permeability(material, span["maximum"] * 1.01)
+        at_edge = PyOpenMagnetics.calculate_complex_permeability(material, span["maximum"])
+        above = PyOpenMagnetics.calculate_complex_permeability(material, span["maximum"] * 1.01)
+        # A finite estimate that continues the table: same sign of both parts as at the span's
+        # end, and mu'' still falling with frequency there.
+        for part in ("real", "imaginary"):
+            assert math.isfinite(above[part])
+            assert above[part] * at_edge[part] > 0
+        assert 0 < above["imaginary"] <= at_edge["imaginary"]