PyOpenMagnetics 1.7.16__tar.gz → 1.7.18__tar.gz

{pyopenmagnetics-1.7.16 → pyopenmagnetics-1.7.18}/CMakeLists.txt

@@ -464,11 +464,15 @@ cmrc_add_resource_library(insulation_standards ALIAS data::insulation_standards
 target_link_libraries(PyOpenMagnetics PUBLIC data::insulation_standards)
 
 
-# Only embed essential data files to reduce binary size
-# Skip large optional datasets like cores_stock.ndjson
+# The MAS catalogues MKF reads at runtime. cores_stock.ndjson is NOT optional: it is the SMALL one
+# (1573 cores vs 18943) and it is what load_cores() reads under settings.useOnlyCoresInStock, the
+# default. Without it MKF used to fall back silently to the full cores.ndjson -- ~2.4 GB resident
+# after load_all_databases(), and an available-cores advise that grew past 16 GB (ABT #1328).
+# MKF now refuses that setting when the stock catalogue is missing, so it must be embedded.
 cmrc_add_resource_library(data ALIAS data::data NAMESPACE data WHENCE ${MAS_DIR} PREFIX MAS 
     ${MAS_DIR}/data/core_materials.ndjson 
     ${MAS_DIR}/data/core_shapes.ndjson 
+    ${MAS_DIR}/data/cores_stock.ndjson 
     ${MAS_DIR}/data/cores.ndjson 
     ${MAS_DIR}/data/bobbins.ndjson 
     ${MAS_DIR}/data/insulation_materials.ndjson 

{pyopenmagnetics-1.7.16 → pyopenmagnetics-1.7.18}/PKG-INFO

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

{pyopenmagnetics-1.7.16 → pyopenmagnetics-1.7.18}/pyproject.toml

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

{pyopenmagnetics-1.7.16 → pyopenmagnetics-1.7.18}/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.16 → pyopenmagnetics-1.7.18}/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.16 → pyopenmagnetics-1.7.18}/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])