PyOpenMagnetics 1.7.6__tar.gz → 1.7.8__tar.gz

{pyopenmagnetics-1.7.6 → pyopenmagnetics-1.7.8}/PKG-INFO

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

{pyopenmagnetics-1.7.6 → pyopenmagnetics-1.7.8}/pyproject.toml

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

pyopenmagnetics-1.7.8/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.6 → pyopenmagnetics-1.7.8}/src/core.cpp

@@ -1,4 +1,5 @@
 #include "core.h"
+#include "constructive_models/CorePiece.h"
 #include "physical_models/ComplexPermeability.h"
 #include <filesystem>
 
@@ -123,6 +124,22 @@ json calculate_core_geometrical_description(json coreDataJson) {
     return result;
 }
 
+// ABT #1002: the IEC shape constants of a moulded body split per region (post, cover, base),
+// so a material fit can attribute each region's reluctance to the powder pressed there.
+json calculate_core_region_shape_constants(json coreDataJson) {
+    OpenMagnetics::Core core(coreDataJson, false, false, false);
+    auto corePiece = OpenMagnetics::CorePiece::factory(core.resolve_shape());
+    auto regions = corePiece->get_region_shape_constants();
+    if (!regions) {
+        throw std::invalid_argument("this shape family does not expose per-region shape constants");
+    }
+    json result = json::array();
+    for (auto& region : *regions) {
+        result.push_back({{"name", region.name}, {"c1", region.c1}, {"c2", region.c2}, {"minimumArea", region.minimumArea}});
+    }
+    return result;
+}
+
 json calculate_core_gapping(json coreDataJson) {
     OpenMagnetics::Core core(coreDataJson, false, false, false);
     core.process_gap_or_throw();
@@ -290,11 +307,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 +323,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 +342,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 +360,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);
@@ -785,6 +792,25 @@ void register_core_bindings(py::module& m) {
         py::arg("core_data_json"),
         py::call_guard<py::gil_scoped_release>());
     
+    m.def("calculate_core_region_shape_constants", &calculate_core_region_shape_constants,
+        R"pbdoc(
+        Per-region IEC shape constants of a moulded body (ABT #1002).
+
+        A compression-moulded body can be pressed from up to three powders: the post the coil
+        sits on, the cover over the coil and the base plate under it. This returns the IEC 60205
+        section sums of each region, in the order functionalDescription.material lists the grades
+        ([post, cover, base]), so a material fit can attribute each region's reluctance to the
+        powder pressed there: R_region = c1 / (mu0 * mu_region), Ae_region = c1 / c2.
+
+        Args:
+            core_data_json: JSON object with functionalDescription (shape family 'molded').
+
+        Returns:
+            JSON array of {name, c1, c2, minimumArea}. Raises for families without regions.
+        )pbdoc",
+        py::arg("core_data_json"),
+        py::call_guard<py::gil_scoped_release>());
+
     m.def("calculate_core_geometrical_description", &calculate_core_geometrical_description,
         R"pbdoc(
         Calculate geometrical description for core visualization.
@@ -1003,7 +1029,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 +1048,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 +1071,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 +1092,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.6 → pyopenmagnetics-1.7.8}/src/core.h

@@ -32,6 +32,7 @@ json get_available_cores();
 json calculate_core_data(json coreDataJson, bool includeMaterialData);
 json calculate_core_processed_description(json coreDataJson);
 json calculate_core_geometrical_description(json coreDataJson);
+json calculate_core_region_shape_constants(json coreDataJson);
 json calculate_core_gapping(json coreDataJson);
 json load_core_data(json coresJson);
 json get_core_temperature_dependant_parameters(json coreData, double temperature);

{pyopenmagnetics-1.7.6 → pyopenmagnetics-1.7.8}/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.6 → pyopenmagnetics-1.7.8}/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.6 → pyopenmagnetics-1.7.8}/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.6/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