PyOpenMagnetics 1.7.18__tar.gz → 1.7.19__tar.gz

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

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

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

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

{pyopenmagnetics-1.7.18 → pyopenmagnetics-1.7.19}/src/advisers.cpp

@@ -222,7 +222,7 @@ json calculate_advised_magnetics_from_catalog(json inputsJson, json catalogJson,
     return results;
 }
 
-json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson, int maximumNumberResults) {
+json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson, int maximumNumberResults, std::optional<std::vector<std::string>> references) {
     OpenMagnetics::settings.set_coil_delimit_and_compact(true);
     OpenMagnetics::Inputs inputs(inputsJson);
 
@@ -237,7 +237,12 @@ json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson
     }
 
     OpenMagnetics::MagneticAdviser magneticAdviser;
-    auto masMagnetics = magneticAdviser.get_advised_magnetic(inputs, OpenMagnetics::magneticsCache.get(), filterFlow, maximumNumberResults);
+    // `references` restricts the search to those cached parts -- one tool's family, or an
+    // admin-chosen pool, out of a cache several callers share. A reference the cache does not
+    // hold raises rather than silently searching fewer parts.
+    auto masMagnetics = references
+        ? magneticAdviser.get_advised_magnetic(inputs, OpenMagnetics::magneticsCache.subset(references.value()), filterFlow, maximumNumberResults)
+        : magneticAdviser.get_advised_magnetic(inputs, OpenMagnetics::magneticsCache.get(), filterFlow, maximumNumberResults);
 
     auto scoringsPerFilter = magneticAdviser.get_scorings();
 
@@ -507,6 +512,11 @@ void register_adviser_bindings(py::module& m) {
             filter_flow_json: JSON array of MagneticFilterOperation objects defining
                               the filtering pipeline.
             max_results: Maximum number of recommendations to return.
+            references: Optional list of cached references (manufacturerInfo.reference) to
+                        search instead of the whole cache. Raises
+                        PyOpenMagnetics.EngineError naming any reference the cache does not
+                        hold. The cache may hold datasheet-only parts (no core, no coil):
+                        they are ranked on the filters that apply to them.
         
         Returns:
             JSON object with "data" array containing ranked results.
@@ -520,7 +530,7 @@ void register_adviser_bindings(py::module& m) {
             Cache must be populated before calling this function.
             Raises PyOpenMagnetics.EngineError if the cache is empty.
         )pbdoc",
-        py::arg("inputs_json"), py::arg("filter_flow_json"), py::arg("max_results"),
+        py::arg("inputs_json"), py::arg("filter_flow_json"), py::arg("max_results"), py::arg("references") = py::none(),
         py::call_guard<py::gil_scoped_release>());
 
     m.def("calculate_manufacturability_report", &calculate_manufacturability_report,

{pyopenmagnetics-1.7.18 → pyopenmagnetics-1.7.19}/src/advisers.h

@@ -12,7 +12,7 @@ json calculate_advised_magnetics(json inputsJson, int maximumNumberResults, json
 json calculate_advised_magnetics_with_filters(json inputsJson, json filterFlowJson, int maximumNumberResults, json coreModeJson);
 json calculate_advised_magnetics_fast(json inputsJson, int maximumNumberResults, json coreModeJson);
 json calculate_advised_magnetics_from_catalog(json inputsJson, json catalogJson, int maximumNumberResults);
-json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson, int maximumNumberResults);
+json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson, int maximumNumberResults, std::optional<std::vector<std::string>> references = std::nullopt);
 
 // Design-for-manufacturing rule pack (ABT #1177, WP8)
 json calculate_manufacturability_report(json masJson);

{pyopenmagnetics-1.7.18 → pyopenmagnetics-1.7.19}/src/core.cpp

@@ -403,6 +403,11 @@ double calculate_saturation_current(json magneticJson, double temperature) {
     return magnetic.calculate_saturation_current(temperature);
 }
 
+std::optional<double> calculate_datasheet_inductance(json magneticJson, double dcBiasCurrent, double temperature) {
+    OpenMagnetics::Magnetic magnetic(magneticJson);
+    return magnetic.calculate_datasheet_inductance(dcBiasCurrent, temperature);
+}
+
 double calculate_saturation_current_at_operating_point(
     json magneticJson, json operatingPointJson, double temperature) {
     OpenMagnetics::Magnetic magnetic(magneticJson);
@@ -1196,6 +1201,29 @@ void register_core_bindings(py::module& m) {
         py::arg("magnetic_json"), py::arg("temperature"),
         py::call_guard<py::gil_scoped_release>());
     
+    m.def("calculate_datasheet_inductance", &calculate_datasheet_inductance,
+        R"pbdoc(
+        Inductance a catalogue part's DATASHEET gives at a DC bias and temperature.
+
+        Reads the measured L(I) points of the part's single-winding inductor entry
+        (manufacturerInfo.datasheetInfo.electrical): linear in current along each measured
+        temperature, linear between the two measured temperatures bracketing `temperature`,
+        and the nearest measured temperature outside that range. Without L(I) points, the
+        stated inductance. Works for datasheet-only parts (no core, no coil).
+
+        Args:
+            magnetic_json: JSON Magnetic object carrying a datasheet.
+            dc_bias_current: DC bias current in Amperes.
+            temperature: Temperature in Celsius.
+
+        Returns:
+            Inductance in Henries, or None when the bias lies beyond the measured curve.
+            Raises PyOpenMagnetics.EngineError when the datasheet gives neither an inductance
+            nor L(I) points.
+        )pbdoc",
+        py::arg("magnetic_json"), py::arg("dc_bias_current"), py::arg("temperature"),
+        py::call_guard<py::gil_scoped_release>());
+
     m.def("calculate_temperature_from_core_thermal_resistance", &calculate_temperature_from_core_thermal_resistance,
         R"pbdoc(
         Calculate core temperature from thermal resistance and losses.

{pyopenmagnetics-1.7.18 → pyopenmagnetics-1.7.19}/src/core.h

@@ -38,6 +38,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);
+std::optional<double> calculate_datasheet_inductance(json magneticJson, double dcBiasCurrent, double temperature);
 double calculate_peak_winding_current(json magneticJson, json operatingPointJson, int windingIndex);
 double calculate_temperature_from_core_thermal_resistance(json coreJson, double totalLosses);
 

pyopenmagnetics-1.7.19/tests/test_datasheet_only_catalogue.py

@@ -0,0 +1,112 @@
+"""
+A catalogue may hold parts known only by their datasheet: no core, no coil, just
+manufacturerInfo.datasheetInfo, which MAS allows. They must load with expansion on, be ranked
+by the cache adviser on the filters that apply to them (datasheet limits, the measured L(I),
+the published body size), and come back in the results rather than be dropped.
+
+`references` restricts a search to part of a cache several callers share.
+"""
+import json
+
+import pytest
+
+import PyOpenMagnetics
+
+
+def datasheet_part(reference, rated_current=3.0):
+    """A 10 uH single-winding inductor known only by its datasheet."""
+    return {
+        "manufacturerInfo": {
+            "name": "Test Maker",
+            "reference": reference,
+            "datasheetInfo": {
+                "electrical": [
+                    {
+                        "subtype": "inductor",
+                        "inductance": {"nominal": 10e-6},
+                        "inductancePoints": [
+                            {"current": 0, "inductance": 10e-6, "temperature": 20},
+                            {"current": 2, "inductance": 9e-6, "temperature": 20},
+                            {"current": 4, "inductance": 6e-6, "temperature": 20},
+                        ],
+                        "ratedCurrents": [rated_current],
+                        "saturationCurrents": [{"percentInductanceDrop": 30, "current": 4.0}],
+                    }
+                ],
+                "mechanical": {"length": {"nominal": 5e-3}, "width": {"nominal": 5e-3}, "height": {"nominal": 3e-3}},
+            },
+        }
+    }
+
+
+def buck_inputs():
+    """9 uH at 1 A DC with 0.4 A ripple, 1 MHz."""
+    inputs = {
+        "designRequirements": {"magnetizingInductance": {"minimum": 8e-6}, "turnsRatios": []},
+        "operatingPoints": [
+            {
+                "name": "op",
+                "conditions": {"ambientTemperature": 25},
+                "excitationsPerWinding": [
+                    {"name": "w", "frequency": 1e6, "current": {"waveform": {"data": [0.8, 1.2, 0.8], "time": [0, 0.5e-6, 1e-6]}}}
+                ],
+            }
+        ],
+    }
+    return PyOpenMagnetics.process_inputs(inputs)
+
+
+FLOW = [
+    {"filter": "Datasheet Limits", "invert": True, "log": False, "strictlyRequired": True, "weight": 1.0},
+    {"filter": "Magnetizing Inductance", "invert": True, "log": False, "strictlyRequired": False, "weight": 1.0},
+    {"filter": "Volume", "invert": True, "log": False, "strictlyRequired": False, "weight": 1.0},
+    {"filter": "Losses", "invert": True, "log": False, "strictlyRequired": False, "weight": 1.0},
+]
+
+
+@pytest.fixture
+def catalogue(tmp_path):
+    PyOpenMagnetics.clear_magnetic_cache()
+    path = tmp_path / "catalogue.ndjson"
+    parts = [datasheet_part("ROOMY", rated_current=5.0), datasheet_part("TIGHT", rated_current=1.3), datasheet_part("OTHER")]
+    path.write_text("\n".join(json.dumps(part) for part in parts) + "\n", encoding="utf-8")
+    PyOpenMagnetics.load_magnetics_from_file(str(path), True)
+    yield
+    PyOpenMagnetics.clear_magnetic_cache()
+
+
+def references_of(result):
+    return [item["mas"]["magnetic"]["manufacturerInfo"]["reference"] for item in result["data"]]
+
+
+def test_datasheet_only_parts_are_ranked_on_the_filters_that_apply(catalogue):
+    result = PyOpenMagnetics.calculate_advised_magnetics_from_cache(buck_inputs(), FLOW, 10)
+
+    assert set(references_of(result)) == {"ROOMY", "TIGHT", "OTHER"}
+    scores = result["data"][0]["scoringPerFilter"]
+    assert "MAGNETIZING_INDUCTANCE" in scores and "VOLUME" in scores
+    # Losses cannot judge a part with no construction: no score, never a stand-in.
+    assert "LOSSES" not in scores
+
+
+def test_the_part_with_more_margin_to_its_ratings_ranks_first(catalogue):
+    flow = [dict(FLOW[0], strictlyRequired=False)]
+    result = PyOpenMagnetics.calculate_advised_magnetics_from_cache(buck_inputs(), flow, 10)
+    order = references_of(result)
+    assert order.index("ROOMY") < order.index("TIGHT")
+
+
+def test_references_restrict_the_search(catalogue):
+    result = PyOpenMagnetics.calculate_advised_magnetics_from_cache(buck_inputs(), FLOW, 10, ["ROOMY", "TIGHT"])
+    assert set(references_of(result)) == {"ROOMY", "TIGHT"}
+
+
+def test_an_unknown_reference_raises_instead_of_searching_less(catalogue):
+    with pytest.raises(Exception, match="not in the cache"):
+        PyOpenMagnetics.calculate_advised_magnetics_from_cache(buck_inputs(), FLOW, 10, ["ROOMY", "MISSING"])
+
+
+def test_datasheet_inductance_at_a_bias():
+    part = datasheet_part("P")
+    assert PyOpenMagnetics.calculate_datasheet_inductance(part, 1.0, 20) == pytest.approx(9.5e-6)
+    assert PyOpenMagnetics.calculate_datasheet_inductance(part, 5.0, 20) is None