PyOpenMagnetics 1.7.15__tar.gz → 1.7.17__tar.gz

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/CMakeLists.txt

@@ -479,6 +479,11 @@ target_link_libraries(PyOpenMagnetics PUBLIC data::data)
 cmrc_add_resource_library(core_losses_data ALIAS data::core_losses_data NAMESPACE coreLossesData ${MKF_DIR}/src/data/core_losses/ciGSE_coefficients.json)
 target_link_libraries(PyOpenMagnetics PUBLIC data::core_losses_data)
 
+# ABT #1177 (MKF WP8): the design-for-manufacturing rule numbers and their sources. MKF opens it
+# as "src/data/dfm_rules.json", hence WHENCE the MKF root (as for the insulation standards).
+cmrc_add_resource_library(dfm_rules ALIAS data::dfm_rules NAMESPACE dfmData WHENCE ${MKF_DIR}/ ${MKF_DIR}/src/data/dfm_rules.json)
+target_link_libraries(PyOpenMagnetics PUBLIC data::dfm_rules)
+
 include_directories("${CMAKE_BINARY_DIR}/_deps/json-src/include/nlohmann/")
 include_directories("${CMAKE_BINARY_DIR}/_deps/pybind11-src/include/")
 include_directories("${CMAKE_BINARY_DIR}/_deps/pybind11_json-src/include/pybind11_json/")

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/PKG-INFO

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

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/pyproject.toml

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

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/src/advisers.cpp

@@ -267,6 +267,15 @@ json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson
     return results;
 }
 
+json calculate_manufacturability_report(json masJson) {
+    OpenMagnetics::Mas mas(masJson);
+    OpenMagnetics::Manufacturability manufacturability;
+    auto report = manufacturability.calculate_report(mas);
+    json result;
+    OpenMagnetics::to_json(result, report);
+    return result;
+}
+
 json calculate_advised_sections(json masJson, json patternJson, int repetitions) {
     OpenMagnetics::Mas mas(masJson);
     std::vector<size_t> pattern;
@@ -514,6 +523,38 @@ void register_adviser_bindings(py::module& m) {
         py::arg("inputs_json"), py::arg("filter_flow_json"), py::arg("max_results"),
         py::call_guard<py::gil_scoped_release>());
 
+    m.def("calculate_manufacturability_report", &calculate_manufacturability_report,
+        R"pbdoc(
+        Run the design-for-manufacturing rule pack over a MAS design.
+
+        Encodes as checks the public Wuerth Elektronik DFM guidance (ABT #1177, WP8). The rule
+        numbers and the source that states each of them live in MKF's src/data/dfm_rules.json.
+        Nothing in the design is changed; this is a report.
+
+        Args:
+            mas: A full MAS object (inputs + magnetic).
+
+        Returns:
+            JSON object with:
+            - "findings": one entry per rule R1..R17, each with "ruleId", "title", "status",
+              "message", "source", and where they exist "measuredValue", "thresholdValue",
+              "unit", "scope", "reason".
+            - "numberPass" / "numberWarnings" / "numberFails" / "numberNotEvaluated" /
+              "numberNotApplicable" / "numberInformational".
+
+            "status" is one of PASS, WARNING, FAIL, INFORMATIONAL, NOT_APPLICABLE,
+            NOT_EVALUATED. NOT_EVALUATED always carries a "reason": a rule that cannot be
+            evaluated says so rather than defaulting to a pass. Rules R2, R3, R4, R10, R11,
+            R14 and R16 are owned by other work packages and report NOT_EVALUATED with the
+            owning work package as the reason.
+
+        Example:
+            >>> report = PyMKF.calculate_manufacturability_report(mas)
+            >>> [f["ruleId"] for f in report["findings"] if f["status"] == "WARNING"]
+        )pbdoc",
+        py::arg("mas"),
+        py::call_guard<py::gil_scoped_release>());
+
     m.def("calculate_advised_sections", &calculate_advised_sections,
         "Get advised coil sections.",
         py::arg("mas"), py::arg("pattern"), py::arg("repetitions"),

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/src/advisers.h

@@ -14,6 +14,9 @@ json calculate_advised_magnetics_fast(json inputsJson, int maximumNumberResults,
 json calculate_advised_magnetics_from_catalog(json inputsJson, json catalogJson, int maximumNumberResults);
 json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson, int maximumNumberResults);
 
+// Design-for-manufacturing rule pack (ABT #1177, WP8)
+json calculate_manufacturability_report(json masJson);
+
 void register_adviser_bindings(py::module& m);
 
 } // namespace PyMKF

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/src/common.h

@@ -10,6 +10,7 @@
 
 #include <MAS.hpp>
 #include "advisers/MagneticAdviser.h"
+#include "advisers/Manufacturability.h"
 #include "constructive_models/Bobbin.h"
 #include "constructive_models/Coil.h"
 #include "constructive_models/Core.h"

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/src/winding.cpp

@@ -500,6 +500,32 @@ json get_isolation_side_from_index(size_t index) {
     return OpenMagnetics::get_isolation_side_from_index(index);
 }
 
+json guess_round_wire_from_dc_resistance(json coilJson, json dcResistancesJson, double maxError) {
+    if (!dcResistancesJson.is_array()) {
+        throw std::invalid_argument("guess_round_wire_from_dc_resistance: dc_resistances must be a list of DC resistances in Ohm, one per winding");
+    }
+    std::vector<double> dcResistances = dcResistancesJson.get<std::vector<double>>();
+    OpenMagnetics::Coil coil(coilJson);
+    if (dcResistances.size() != coil.get_functional_description().size()) {
+        throw std::invalid_argument("guess_round_wire_from_dc_resistance: got " + std::to_string(dcResistances.size()) +
+                                    " DC resistances for a coil with " + std::to_string(coil.get_functional_description().size()) + " windings");
+    }
+    for (size_t index = 0; index < dcResistances.size(); ++index) {
+        if (!(dcResistances[index] > 0)) {
+            throw std::invalid_argument("guess_round_wire_from_dc_resistance: DC resistance of winding " + std::to_string(index) +
+                                        " must be positive, got " + std::to_string(dcResistances[index]));
+        }
+    }
+
+    json result = json::array();
+    for (auto& wire : coil.guess_round_wire_from_dc_resistance(dcResistances, maxError)) {
+        json aux;
+        to_json(aux, wire);
+        result.push_back(aux);
+    }
+    return result;
+}
+
 json set_interlayer_insulation(json coilJson, double layerThickness) {
     OpenMagnetics::Coil coil(coilJson, false);
     coil.set_interlayer_insulation(layerThickness);
@@ -868,6 +894,32 @@ void register_winding_bindings(py::module& m) {
         py::arg("index"),
         py::call_guard<py::gil_scoped_release>());
 
+    m.def("guess_round_wire_from_dc_resistance", &guess_round_wire_from_dc_resistance,
+        R"pbdoc(
+        Guess the round wire of each winding from its measured DC resistance.
+
+        Winds the coil, then iteratively replaces each winding's wire with the
+        round wire whose DC resistance per meter matches the target over the
+        wound wire length, re-winding until every winding is within max_error
+        (or the chosen wires stop changing).
+
+        Args:
+            coil_json: JSON Coil with bobbin and functionalDescription (any
+                initial wire; it is replaced).
+            dc_resistances: DC resistance in Ohm per winding, same order as
+                functionalDescription.
+            max_error: Maximum relative DC-resistance error (default 0.05).
+
+        Returns:
+            JSON array of Wire objects, one per winding.
+
+        Raises:
+            EngineError if dc_resistances is not a list, its length differs from
+            the number of windings, or any value is not positive.
+        )pbdoc",
+        py::arg("coil_json"), py::arg("dc_resistances"), py::arg("max_error") = 0.05,
+        py::call_guard<py::gil_scoped_release>());
+
     m.def("set_interlayer_insulation", &set_interlayer_insulation,
         R"pbdoc(
         Set interlayer insulation for a coil.

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/src/winding.h

@@ -39,6 +39,9 @@ json set_interlayer_insulation(json coilJson, double layerThickness);
 json set_intersection_insulation(json coilJson, double layerThickness, int numberInsulationLayers);
 json get_solid_insulation_requirements_for_wires(json inputsJson, json patternJson, int repetitions);
 
+// Wire estimation
+json guess_round_wire_from_dc_resistance(json coilJson, json dcResistancesJson, double maxError);
+
 void register_winding_bindings(py::module& m);
 
 } // namespace PyMKF

{pyopenmagnetics-1.7.15 → pyopenmagnetics-1.7.17}/tests/test_winding.py

@@ -99,3 +99,58 @@ class TestInsulationMaterials:
         if len(names) > 0:
             material = PyOpenMagnetics.find_insulation_material_by_name(names[0])
             assert isinstance(material, dict)
+
+
+class TestGuessRoundWireFromDcResistance:
+    """Round-wire estimation from measured per-winding DC resistance."""
+
+    @staticmethod
+    def _current_transformer_coil(sample_toroidal_core, primary_wire, secondary_wire):
+        core = PyOpenMagnetics.calculate_core_data(sample_toroidal_core, False)
+        bobbin = PyOpenMagnetics.create_basic_bobbin(core, True)
+        return {
+            "bobbin": bobbin,
+            "functionalDescription": [
+                {"name": "primary", "numberTurns": 1, "numberParallels": 1,
+                 "isolationSide": PyOpenMagnetics.get_isolation_side_from_index(0), "wire": primary_wire},
+                {"name": "secondary", "numberTurns": 50, "numberParallels": 1,
+                 "isolationSide": PyOpenMagnetics.get_isolation_side_from_index(1), "wire": secondary_wire},
+            ],
+        }
+
+    def test_round_trip_recovers_dc_resistance(self, sample_toroidal_core):
+        """Wires guessed from a known coil's DC resistances reproduce those resistances."""
+        reference = self._current_transformer_coil(sample_toroidal_core, "Round 0.90 - Grade 1", "Round 0.212 - Grade 1")
+        wound = PyOpenMagnetics.wind(reference, 1, [0.5, 0.5], [0, 1], [])
+        dc_resistances = PyOpenMagnetics.calculate_dc_resistance_per_winding(wound, 25)
+
+        # Start from the thinnest wire, as heimdall's current-transformer translator does.
+        guess = self._current_transformer_coil(sample_toroidal_core, "Round 0.01 - Grade 1", "Round 0.01 - Grade 1")
+        wires = PyOpenMagnetics.guess_round_wire_from_dc_resistance(guess, dc_resistances)
+
+        assert isinstance(wires, list)
+        assert len(wires) == 2
+        for wire in wires:
+            assert wire["type"] == "round"
+
+        # A 1-turn primary needs a far thicker conductor than a 50-turn secondary.
+        assert wires[0]["conductingDiameter"]["nominal"] > wires[1]["conductingDiameter"]["nominal"]
+
+        guess["functionalDescription"][0]["wire"] = wires[0]
+        guess["functionalDescription"][1]["wire"] = wires[1]
+        rewound = PyOpenMagnetics.wind(guess, 1, [0.5, 0.5], [0, 1], [])
+        recovered = PyOpenMagnetics.calculate_dc_resistance_per_winding(rewound, 25)
+        for target, value in zip(dc_resistances, recovered):
+            assert abs(value - target) / target < 0.05
+
+    def test_rejects_resistance_count_mismatch(self, sample_toroidal_core):
+        """One DC resistance per winding is required."""
+        coil = self._current_transformer_coil(sample_toroidal_core, "Round 0.01 - Grade 1", "Round 0.01 - Grade 1")
+        with pytest.raises(PyOpenMagnetics.EngineError):
+            PyOpenMagnetics.guess_round_wire_from_dc_resistance(coil, [0.001])
+
+    def test_rejects_non_positive_resistance(self, sample_toroidal_core):
+        """A zero DC resistance has no wire and must not be silently mapped to one."""
+        coil = self._current_transformer_coil(sample_toroidal_core, "Round 0.01 - Grade 1", "Round 0.01 - Grade 1")
+        with pytest.raises(PyOpenMagnetics.EngineError):
+            PyOpenMagnetics.guess_round_wire_from_dc_resistance(coil, [0.001, 0.0])