PyOpenMagnetics 1.5.0__tar.gz → 1.5.1__tar.gz

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/CMakeLists.txt

@@ -218,7 +218,15 @@ add_custom_command(
   OUTPUT "${MAS_DIRECTORY}/MAS.hpp"
   # Force regeneration by removing output first
   COMMAND ${CMAKE_COMMAND} -E remove -f ${MAS_DIRECTORY}/MAS.hpp
-  COMMAND quicktype -l c++ -s schema ${MAS_DIR}/schemas/MAS.json 
+  COMMAND quicktype -l c++ -s schema ${MAS_DIR}/schemas/MAS.json
+    # PEAS schemas: MAS main ($id https://psma.com/mas/...) now $refs shared
+    # PEAS primitives (https://psma.com/peas/...). quicktype resolves those
+    # external $refs by $id from sources passed with -S, so the PEAS schemas
+    # must be fed in here. PEAS is an MKF submodule at ${MKF_DIR}/PEAS.
+    -S ${MKF_DIR}/PEAS/schemas/utils.json
+    -S ${MKF_DIR}/PEAS/schemas/inputs/operatingPointExcitation.json
+    -S ${MKF_DIR}/PEAS/schemas/outputs/insulationCoordination.json
+    -S ${MKF_DIR}/PEAS/schemas/outputs/lossElementPerHarmonic.json
     -S ${MAS_DIR}/schemas/magnetic.json
     -S ${MAS_DIR}/schemas/magnetic/core.json
     -S ${MAS_DIR}/schemas/magnetic/coil.json

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/PKG-INFO

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

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/examples/complete_simulation_example.py

@@ -179,8 +179,7 @@ def simulate_losses(magnetic, specs):
     print("\n[1] Calculating core losses...")
     models = {
         "coreLosses": "IGSE",
-        "reluctance": "ZHANG",
-        "coreTemperature": "MANIKTALA"
+        "reluctance": "ZHANG"
     }
     
     try:

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/examples/flyback_220v_12v_1a.py

@@ -287,8 +287,7 @@ def design_flyback_transformer():
     
     models = {
         "coreLosses": "IGSE",
-        "reluctance": "ZHANG",
-        "coreTemperature": "MANIKTALA"
+        "reluctance": "ZHANG"
     }
     
     best_design = None

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/examples/flyback_220v_12v_2a_complete.py

@@ -301,8 +301,7 @@ def design_flyback_transformer():
     
     models = {
         "coreLosses": "IGSE",
-        "reluctance": "ZHANG",
-        "coreTemperature": "MANIKTALA"
+        "reluctance": "ZHANG"
     }
     
     best_design = None

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/examples/flyback_design.py

@@ -127,8 +127,7 @@ def design_flyback_transformer():
     
     models = {
         "coreLosses": "IGSE",
-        "reluctance": "ZHANG",
-        "coreTemperature": "MANIKTALA"
+        "reluctance": "ZHANG"
     }
     
     for i, item in enumerate(magnetics):

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/pyproject.toml

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

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/src/core.cpp

@@ -430,6 +430,70 @@ double calculate_saturation_current_at_operating_point(
     return magnetic.calculate_saturation_current(op, temperature);
 }
 
+double calculate_peak_winding_current(json magneticJson, json operatingPointJson, int windingIndex) {
+    OpenMagnetics::Magnetic magnetic(magneticJson);
+    MAS::OperatingPoint op;
+    from_json(operatingPointJson, op);
+
+    // Operating-point magnetizing inductance of the as-designed magnetic
+    // (gapped circuit + DC-bias rolloff). Same L the saturation-current
+    // accessor uses, so I_peak and I_sat stay on a consistent footing.
+    OpenMagnetics::MagnetizingInductance magnetizingInductanceCalc;
+    auto inductanceOutput =
+        magnetizingInductanceCalc.calculate_inductance_from_number_turns_and_gapping(
+            magnetic.get_mutable_core(), magnetic.get_mutable_coil(), &op);
+    auto inductanceNominal = inductanceOutput.get_magnetizing_inductance().get_nominal();
+    if (!inductanceNominal.has_value() || inductanceNominal.value() <= 0) {
+        throw std::runtime_error(
+            "calculate_peak_winding_current: operating-point magnetizing "
+            "inductance is missing or non-positive — cannot derive the "
+            "magnetizing current.");
+    }
+    double magnetizingInductance = inductanceNominal.value();
+
+    auto excitations = op.get_mutable_excitations_per_winding();
+    if (excitations.empty()) {
+        throw std::runtime_error(
+            "calculate_peak_winding_current: operating point has no winding "
+            "excitations.");
+    }
+
+    // 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];
+    auto magnetizingCurrent = OpenMagnetics::Inputs::calculate_magnetizing_current(
+        primaryExcitation, magnetizingInductance, true, true);
+    auto processed = magnetizingCurrent.get_processed();
+    if (!processed.has_value() || !processed->get_peak().has_value()) {
+        throw std::runtime_error(
+            "calculate_peak_winding_current: computed magnetizing current has "
+            "no processed peak.");
+    }
+    double primaryPeak = processed->get_peak().value();
+
+    if (windingIndex == 0) {
+        return primaryPeak;
+    }
+
+    // Saturation is a single-flux core property; the magnetizing current
+    // referred to winding i is the primary-referred value scaled by the
+    // turns ratio: I_mag_i = I_mag_0 · N_0 / N_i.
+    double numberTurnsPrimary =
+        static_cast<double>(magnetic.get_mutable_coil().get_number_turns(0));
+    double numberTurnsWinding =
+        static_cast<double>(magnetic.get_mutable_coil().get_number_turns(windingIndex));
+    if (numberTurnsWinding <= 0) {
+        throw std::runtime_error(
+            "calculate_peak_winding_current: winding " +
+            std::to_string(windingIndex) + " has no turns — cannot refer the "
+            "magnetizing current to it.");
+    }
+    return primaryPeak * numberTurnsPrimary / numberTurnsWinding;
+}
+
 double calculate_temperature_from_core_thermal_resistance(json coreJson, double totalLosses) {
     OpenMagnetics::Core core(coreJson);
     
@@ -1073,6 +1137,40 @@ void register_core_bindings(py::module& m) {
         py::arg("magnetic_json"), py::arg("operating_point_json"),
         py::arg("temperature"));
 
+    m.def("calculate_peak_winding_current",
+        &calculate_peak_winding_current,
+        R"pbdoc(
+        Peak magnetizing (flux-driving) current at an operating point.
+
+        Returns the peak of the magnetizing current — the quantity that
+        actually drives core flux and therefore saturation — for the
+        as-designed magnetic at the supplied operating point. This is the
+        consistent partner to ``calculate_saturation_current_at_operating_point``:
+        both use the same operating-point magnetizing inductance, so the
+        caller can compare I_peak against I_sat on the same footing.
+
+        The magnetizing current is computed by MKF from the primary voltage
+        waveform (``I_mag = (1/L) ∫ v dt``) with the operating DC bias folded
+        in, NOT read back from the input current. For a transformer this is
+        the genuine flux-driving current, which differs from the primary
+        winding current (the latter includes reflected load current that
+        produces no net flux).
+
+        Args:
+            magnetic_json: JSON Magnetic object (core + coil).
+            operating_point_json: JSON OperatingPoint object with at least the
+                primary winding voltage excitation.
+            winding_index: Winding the result is referred to (default 0,
+                primary). For other windings the primary-referred peak is
+                scaled by the turns ratio N_0 / N_i — saturation is a single
+                core-flux property, so this is largely a unit choice.
+
+        Returns:
+            Peak magnetizing current in Amperes.
+        )pbdoc",
+        py::arg("magnetic_json"), py::arg("operating_point_json"),
+        py::arg("winding_index") = 0);
+
     m.def("calculate_saturation_current", &calculate_saturation_current,
         R"pbdoc(
         Calculate saturation current for a complete magnetic.

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/src/core.h

@@ -37,6 +37,7 @@ json load_core_data(json coresJson);
 json get_core_temperature_dependant_parameters(json coreData, double temperature);
 double calculate_core_maximum_magnetic_energy(json coreDataJson, json operatingPointJson);
 double calculate_saturation_current(json magneticJson, double temperature);
+double calculate_peak_winding_current(json magneticJson, json operatingPointJson, int windingIndex);
 double calculate_temperature_from_core_thermal_resistance(json coreJson, double totalLosses);
 
 // Gap and reluctance

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/src/losses.cpp

@@ -25,10 +25,6 @@ json calculate_core_losses(json coreData, json coilData, json inputsData, json m
     if (models.find("coreLosses") != models.end()) {
         OpenMagnetics::from_json(models["coreLosses"], coreLossesModelName);
     }
-    auto coreTemperatureModelName = OpenMagnetics::defaults.coreTemperatureModelDefault;
-    if (models.find("coreTemperature") != models.end()) {
-        OpenMagnetics::from_json(models["coreTemperature"], coreTemperatureModelName);
-    }
 
     OpenMagnetics::Magnetic magnetic;
     magnetic.set_core(core);
@@ -36,7 +32,6 @@ json calculate_core_losses(json coreData, json coilData, json inputsData, json m
 
     OpenMagnetics::MagneticSimulator magneticSimulator;
     magneticSimulator.set_core_losses_model_name(coreLossesModelName);
-    magneticSimulator.set_core_temperature_model_name(coreTemperatureModelName);
     magneticSimulator.set_reluctance_model_name(reluctanceModelName);
     auto coreLossesOutput = magneticSimulator.calculate_core_losses(operatingPoint, magnetic);
     json result;
@@ -66,15 +61,6 @@ json get_core_losses_model_information(json material) {
     return info;
 }
 
-json get_core_temperature_model_information() {
-    json info;
-    info["information"] = OpenMagnetics::CoreTemperatureModel::get_models_information();
-    info["errors"] = OpenMagnetics::CoreTemperatureModel::get_models_errors();
-    info["internal_links"] = OpenMagnetics::CoreTemperatureModel::get_models_internal_links();
-    info["external_links"] = OpenMagnetics::CoreTemperatureModel::get_models_external_links();
-    return info;
-}
-
 json calculate_steinmetz_coefficients(json dataJson, json rangesJson) {
     try {
         std::vector<std::pair<double, double>> ranges;
@@ -383,7 +369,6 @@ void register_losses_bindings(py::module& m) {
             models_data: JSON dict specifying models to use:
                 - "coreLosses": "STEINMETZ", "IGSE", "MSE", "BARG", "ROSHEN", "PROPRIETARY"
                 - "reluctance": "ZHANG", "MUEHLETHALER", "PARTRIDGE", "STENGLEIN"
-                - "coreTemperature": Model for temperature estimation
         
         Returns:
             JSON object containing:
@@ -423,14 +408,6 @@ void register_losses_bindings(py::module& m) {
         )pbdoc",
         py::arg("material"));
     
-    m.def("get_core_temperature_model_information", &get_core_temperature_model_information,
-        R"pbdoc(
-        Get documentation for available core temperature models.
-        
-        Returns:
-            JSON object with model information, errors, and reference links.
-        )pbdoc");
-    
     m.def("calculate_steinmetz_coefficients", &calculate_steinmetz_coefficients,
         R"pbdoc(
         Fit Steinmetz equation coefficients from measured loss data.

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/src/losses.h

@@ -7,7 +7,6 @@ namespace PyMKF {
 // Core losses
 json calculate_core_losses(json coreData, json coilData, json inputsData, json modelsData);
 json get_core_losses_model_information(json material);
-json get_core_temperature_model_information();
 json calculate_steinmetz_coefficients(json dataJson, json rangesJson);
 json calculate_steinmetz_coefficients_with_error(json dataJson, json rangesJson);
 

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/src/simulation.cpp

@@ -15,14 +15,9 @@ json simulate(json inputsJson, json magneticJson, json modelsData) {
         if (!modelsData.is_null() && modelsData.find("coreLosses") != modelsData.end()) {
             OpenMagnetics::from_json(modelsData["coreLosses"], coreLossesModelName);
         }
-        auto coreTemperatureModelName = OpenMagnetics::defaults.coreTemperatureModelDefault;
-        if (!modelsData.is_null() && modelsData.find("coreTemperature") != modelsData.end()) {
-            OpenMagnetics::from_json(modelsData["coreTemperature"], coreTemperatureModelName);
-        }
-        
+
         OpenMagnetics::MagneticSimulator magneticSimulator;
         magneticSimulator.set_core_losses_model_name(coreLossesModelName);
-        magneticSimulator.set_core_temperature_model_name(coreTemperatureModelName);
         magneticSimulator.set_reluctance_model_name(reluctanceModelName);
         auto mas = magneticSimulator.simulate(inputs, magnetic);
 

{pyopenmagnetics-1.5.0 → pyopenmagnetics-1.5.1}/tests/test_core.py

@@ -181,6 +181,90 @@ class TestCoreCalculations:
             assert isinstance(gapping, list)
 
 
+class TestPeakWindingCurrent:
+    """
+    Tests for calculate_peak_winding_current (ABT #16).
+
+    Verifies the binding that exposes the MKF-computed peak magnetizing
+    (flux-driving) current at an operating point, so Heaviside no longer
+    needs analytical I_peak fallbacks.
+    """
+
+    def _advise_magnetic(self, inputs):
+        proc = PyOpenMagnetics.process_inputs(inputs)
+        res = PyOpenMagnetics.calculate_advised_magnetics(proc, 1, "available cores")
+        data = json.loads(res) if isinstance(res, str) else res
+        data = data["data"] if isinstance(data, dict) and "data" in data else data
+        assert len(data) > 0, "adviser returned no magnetic"
+        mas = data[0].get("mas", data[0])
+        return mas["magnetic"], mas["inputs"]["operatingPoints"][0]
+
+    def test_inductor_peak_includes_dc_bias(self):
+        """
+        Peak magnetizing current must fold in the operating DC bias, not
+        return only the AC ripple amplitude. Input current here is a 5 A DC
+        bias with a 4 A peak-to-peak ripple.
+        """
+        op = {
+            "name": "Nominal",
+            "conditions": {"ambientTemperature": 25},
+            "excitationsPerWinding": [{
+                "frequency": 100000,
+                "current": {"waveform": {"data": [3, 7, 3],
+                                         "time": [0, 0.0000025, 0.00001]}},
+                "voltage": {"waveform": {"data": [-10, 30, 30, -10, -10],
+                                         "time": [0, 0, 0.0000025, 0.0000025, 0.00001]}},
+            }],
+        }
+        inputs = {
+            "designRequirements": {"magnetizingInductance": {"nominal": 100e-6},
+                                   "turnsRatios": []},
+            "operatingPoints": [op],
+        }
+        magnetic, op_used = self._advise_magnetic(inputs)
+
+        ipeak = PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used, 0)
+        # Default winding_index argument must match explicit 0.
+        assert ipeak == PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used)
+        assert ipeak > 0
+        # Must include the ~5 A DC bias, so well above the bare ripple amplitude.
+        assert ipeak > 4.0
+
+        # Consistent footing with I_sat at the same operating point.
+        isat = PyOpenMagnetics.calculate_saturation_current_at_operating_point(
+            magnetic, op_used, 25.0)
+        assert isat > ipeak  # an advised design should not be saturating
+
+    def test_transformer_winding_index_scales_by_turns_ratio(self):
+        """
+        For a transformer the per-winding magnetizing peak is the primary
+        value scaled by the turns ratio N_0 / N_i.
+        """
+        op = {
+            "name": "Nominal",
+            "conditions": {"ambientTemperature": 25},
+            "excitationsPerWinding": [{
+                "frequency": 100000,
+                "current": {"waveform": {"data": [-5, 5, -5],
+                                         "time": [0, 0.0000025, 0.00001]}},
+                "voltage": {"waveform": {"data": [-10, 30, 30, -10, -10],
+                                         "time": [0, 0, 0.0000025, 0.0000025, 0.00001]}},
+            }],
+        }
+        inputs = {
+            "designRequirements": {"magnetizingInductance": {"nominal": 100e-6},
+                                   "turnsRatios": [{"nominal": 2.0}]},
+            "operatingPoints": [op],
+        }
+        magnetic, op_used = self._advise_magnetic(inputs)
+        turns = [w["numberTurns"]
+                 for w in magnetic["coil"]["functionalDescription"]]
+
+        p0 = PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used, 0)
+        p1 = PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used, 1)
+        assert p1 == pytest.approx(p0 * turns[0] / turns[1], rel=1e-9)
+
+
 class TestCoreProcessedDescription:
     """Test suite for processed core descriptions."""