PyOpenMagnetics 1.6.3__tar.gz → 1.6.4__tar.gz

{pyopenmagnetics-1.6.3 → pyopenmagnetics-1.6.4}/.github/workflows/ci.yml

@@ -1,90 +1,106 @@
-name: CI
-
-on:
-  push:
-    branches: [main, master, develop]
-  pull_request:
-    branches: [main, master, develop]
-
-env:
-  GIT_LFS_SKIP_SMUDGE: 1  # Skip LFS to avoid bandwidth quota issues
-
-jobs:
-  test:
-    name: Test on ${{ matrix.os }} / Python ${{ matrix.python-version }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-22.04, windows-2022, macos-14]
-        python-version: ["3.10", "3.11", "3.12"]
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "18"
-
-      - name: Install quicktype
-        run: npm install -g quicktype
-
-      - name: Install build dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install build pytest
-
-      - name: Build and install package
-        run: |
-          pip install .
-
-      - name: Verify installation
-        run: |
-          python -c "import PyOpenMagnetics; print('PyOpenMagnetics loaded with', len(dir(PyOpenMagnetics)), 'functions')"
-
-      - name: Run tests
-        run: |
-          pytest tests/ -v --tb=short
-        continue-on-error: true  # Some tests may require specific data files
-
-  build_check:
-    name: Build check
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "18"
-
-      - name: Install quicktype
-        run: npm install -g quicktype
-
-      - name: Install build
-        run: python -m pip install build
-
-      - name: Build package
-        run: python -m build
-
-      - name: Check built files
-        run: |
-          ls -la dist/
-          echo "--- Wheel contents ---"
-          python -m zipfile -l dist/*.whl | head -50
-
+name: CI
+
+on:
+  push:
+    branches: [main, master, develop]
+  pull_request:
+    branches: [main, master, develop]
+
+env:
+  GIT_LFS_SKIP_SMUDGE: 1  # Skip LFS to avoid bandwidth quota issues
+
+jobs:
+  test:
+    name: Test on ${{ matrix.os }} / Python ${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, windows-2022, macos-14]
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+
+      - name: Rewrite SSH submodule URLs to HTTPS
+        # Kirchhoff (fetched at build time by CMake ExternalProject) declares its
+        # PSMA schema submodules with git@github.com: URLs, which a runner cannot
+        # authenticate -> "Permission denied (publickey)" and a failed wheel build.
+        # publish.yml already does this inside CIBW_BEFORE_ALL_*; CI never did,
+        # which is why every CI job was red on every OS while publish stayed green.
+        run: git config --global url."https://github.com/".insteadOf "git@github.com:"
+
+      - name: Install quicktype
+        run: npm install -g quicktype@23.2.6
+
+      - name: Install build dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build pytest
+
+      - name: Build and install package
+        run: |
+          pip install .
+
+      - name: Verify installation
+        run: |
+          python -c "import PyOpenMagnetics; print('PyOpenMagnetics loaded with', len(dir(PyOpenMagnetics)), 'functions')"
+
+      - name: Run tests
+        run: |
+          pytest tests/ -v --tb=short
+        continue-on-error: true  # Some tests may require specific data files
+
+  build_check:
+    name: Build check
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+
+      - name: Rewrite SSH submodule URLs to HTTPS
+        # Kirchhoff (fetched at build time by CMake ExternalProject) declares its
+        # PSMA schema submodules with git@github.com: URLs, which a runner cannot
+        # authenticate -> "Permission denied (publickey)" and a failed wheel build.
+        # publish.yml already does this inside CIBW_BEFORE_ALL_*; CI never did,
+        # which is why every CI job was red on every OS while publish stayed green.
+        run: git config --global url."https://github.com/".insteadOf "git@github.com:"
+
+      - name: Install quicktype
+        run: npm install -g quicktype@23.2.6
+
+      - name: Install build
+        run: python -m pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Check built files
+        run: |
+          ls -la dist/
+          echo "--- Wheel contents ---"
+          python -m zipfile -l dist/*.whl | head -50
+

{pyopenmagnetics-1.6.3 → pyopenmagnetics-1.6.4}/CMakeLists.txt

@@ -142,7 +142,7 @@ if(NOT LOCAL_MKF_MAS)
     set(MKF_GIT_TAG "main"
         CACHE STRING "MKF git ref for the vendored PyOM build")
     # Force fresh clone by using a unique timestamp - update this when the pin changes
-    set(MKF_FORCE_REFRESH "2026-07-09-cm-sweep-permeability-poco")
+    set(MKF_FORCE_REFRESH "2026-08-05-v1.6.4-mkf-dragback-adviser-thermal")
     # Tell MKF to disable matplotplusplus and use SVG-based Painter instead
     set(INCLUDE_PYMKF ON CACHE BOOL "Build Python interface" FORCE)
     # GIT_SUBMODULES_RECURSE pulls in CAS/PEAS (added 2026-04 alongside the
@@ -243,6 +243,10 @@ endif()
 message(STATUS "Compiling MAS")
 
 
+# Every schema the generated header is built from — the DEPENDS list below.
+file(GLOB_RECURSE MAS_SCHEMA_FILES CONFIGURE_DEPENDS "${MAS_DIR}/schemas/*.json")
+file(GLOB_RECURSE PEAS_SCHEMA_FILES CONFIGURE_DEPENDS "${MKF_DIR}/PEAS/schemas/*.json")
+
 add_custom_command(
   OUTPUT "${MAS_DIRECTORY}/MAS.hpp"
   # Force regeneration by removing output first
@@ -321,6 +325,15 @@ add_custom_command(
     -S ${MAS_DIR}/schemas/inputs/topologies/seriesResonant.json
     -S ${MAS_DIR}/schemas/inputs/topologies/vienna.json
     -o ${MAS_DIRECTORY}/MAS.hpp --namespace MAS --source-style single-source --type-style pascal-case --member-style underscore-case --enumerator-style upper-underscore-case --no-boost
+  # WITHOUT THIS, CMake treats MAS.hpp as up to date forever once the file
+  # exists: no dependency is declared, so the schemas can change and the header
+  # silently keeps stale members. That is how a 6 July MAS.hpp survived a 28 July
+  # schema and broke MKF's Coil.h on Winding::set_winding_window — the schema had
+  # `windingWindow`, the generated class did not. (The `remove -f` above does NOT
+  # help: it runs only once CMake has already decided to regenerate.)
+  # Globbed rather than repeating the ~80-entry -S list, which would drift out of
+  # sync with it; CONFIGURE_DEPENDS also re-globs when a schema file is added.
+  DEPENDS ${MAS_SCHEMA_FILES} ${PEAS_SCHEMA_FILES}
   USES_TERMINAL)
 
 add_custom_target(PyMASGeneration

{pyopenmagnetics-1.6.3 → pyopenmagnetics-1.6.4}/PKG-INFO

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

{pyopenmagnetics-1.6.3 → pyopenmagnetics-1.6.4}/pyproject.toml

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

pyopenmagnetics-1.6.4/src/crossref.cpp

@@ -0,0 +1,164 @@
+#include "crossref.h"
+
+#include "advisers/CoreCrossReferencer.h"
+#include "advisers/CoreMaterialCrossReferencer.h"
+
+namespace PyMKF {
+
+// The cross-referencers were reachable only from the WASM build (the web app's
+// `crossReferencers` module), so a Python consumer could not offer the
+// CoreCrossReferencer / CoreMaterialCrossReferencer tools the app has. These
+// mirror that surface, following the same {"data": ...} envelope and
+// "Exception: ..." error convention as the advisers.
+
+json calculate_cross_referenced_core(json referenceCoreJson, json inputsJson,
+                                     int64_t referenceNumberTurns, json weightsJson,
+                                     int maximumNumberResults) {
+    try {
+        OpenMagnetics::Core referenceCore(referenceCoreJson);
+        OpenMagnetics::Inputs inputs(inputsJson);
+
+        std::map<std::string, double> weightsKeysJson = weightsJson;
+        std::map<OpenMagnetics::CoreCrossReferencerFilters, double> weights;
+        for (auto const& [filterName, weight] : weightsKeysJson) {
+            OpenMagnetics::CoreCrossReferencerFilters filter;
+            OpenMagnetics::from_json(filterName, filter);
+            weights[filter] = weight;
+        }
+
+        OpenMagnetics::CoreCrossReferencer coreCrossReferencer;
+        auto scoredCores = weights.empty()
+            ? coreCrossReferencer.get_cross_referenced_core(referenceCore, referenceNumberTurns,
+                                                            inputs, maximumNumberResults)
+            : coreCrossReferencer.get_cross_referenced_core(referenceCore, referenceNumberTurns,
+                                                            inputs, weights, maximumNumberResults);
+
+        auto scoringsPerFilter = coreCrossReferencer.get_scorings();
+
+        json results = json();
+        results["data"] = json::array();
+        for (auto& [core, scoring] : scoredCores) {
+            json result;
+            json coreJson;
+            to_json(coreJson, core);
+            result["core"] = coreJson;
+            result["scoring"] = scoring;
+
+            std::string name = core.get_name().value_or("");
+            if (scoringsPerFilter.count(name)) {
+                json filterScorings;
+                for (auto& [filter, filterScore] : scoringsPerFilter[name]) {
+                    filterScorings[std::string(magic_enum::enum_name(filter))] = filterScore;
+                }
+                result["scoringPerFilter"] = filterScorings;
+            }
+            results["data"].push_back(result);
+        }
+
+        OpenMagnetics::settings.reset();
+        return results;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
+json calculate_cross_referenced_core_material(json referenceCoreMaterialJson, double temperature,
+                                              json weightsJson, int maximumNumberResults) {
+    try {
+        CoreMaterial referenceCoreMaterial(referenceCoreMaterialJson);
+
+        std::map<std::string, double> weightsKeysJson = weightsJson;
+        std::map<OpenMagnetics::CoreMaterialCrossReferencerFilters,
+                 double> weights;
+        for (auto const& [filterName, weight] : weightsKeysJson) {
+            OpenMagnetics::CoreMaterialCrossReferencerFilters filter;
+            OpenMagnetics::from_json(filterName, filter);
+            weights[filter] = weight;
+        }
+
+        OpenMagnetics::CoreMaterialCrossReferencer coreMaterialCrossReferencer;
+        auto scoredMaterials = weights.empty()
+            ? coreMaterialCrossReferencer.get_cross_referenced_core_material(
+                  referenceCoreMaterial, temperature, maximumNumberResults)
+            : coreMaterialCrossReferencer.get_cross_referenced_core_material(
+                  referenceCoreMaterial, temperature, weights, maximumNumberResults);
+
+        auto scoringsPerFilter = coreMaterialCrossReferencer.get_scorings();
+
+        json results = json();
+        results["data"] = json::array();
+        for (auto& [material, scoring] : scoredMaterials) {
+            json result;
+            json materialJson;
+            to_json(materialJson, material);
+            result["material"] = materialJson;
+            result["scoring"] = scoring;
+
+            std::string name = material.get_name();
+            if (scoringsPerFilter.count(name)) {
+                json filterScorings;
+                for (auto& [filter, filterScore] : scoringsPerFilter[name]) {
+                    filterScorings[std::string(magic_enum::enum_name(filter))] = filterScore;
+                }
+                result["scoringPerFilter"] = filterScorings;
+            }
+            results["data"].push_back(result);
+        }
+
+        OpenMagnetics::settings.reset();
+        return results;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
+void register_crossref_bindings(py::module& m) {
+    m.def("calculate_cross_referenced_core", &calculate_cross_referenced_core,
+        R"pbdoc(
+        Rank cores that could replace a reference core.
+
+        Args:
+            reference_core_json: the core being replaced (shape, material, gapping).
+            inputs_json: design requirements and operating points the replacement must meet.
+            reference_number_turns: turns on the reference design.
+            weights_json: optional filter weights. Keys: "PERMEANCE", "CORE_LOSSES",
+                          "SATURATION", "WINDING_WINDOW_AREA", "EFFECTIVE_AREA",
+                          "ENVELOPING_VOLUME". Empty uses the adviser's defaults.
+            max_results: how many alternatives to return.
+
+        Returns:
+            {"data": [{"core", "scoring", "scoringPerFilter"}]} best first, or
+            {"data": "Exception: ..."} on failure.
+        )pbdoc",
+        py::arg("reference_core_json"), py::arg("inputs_json"),
+        py::arg("reference_number_turns"), py::arg("weights_json") = json::object(),
+        py::arg("max_results") = 10);
+
+    m.def("calculate_cross_referenced_core_material", &calculate_cross_referenced_core_material,
+        R"pbdoc(
+        Rank core materials that could replace a reference material.
+
+        Args:
+            reference_core_material_json: the material being replaced.
+            temperature: operating temperature in Celsius (material properties are
+                         strongly temperature dependent, so this is not optional).
+            weights_json: optional filter weights. Keys: "INITIAL_PERMEABILITY",
+                          "REMANENCE", "COERCIVE_FORCE", "SATURATION",
+                          "CURIE_TEMPERATURE", "VOLUMETRIC_LOSSES".
+            max_results: how many alternatives to return.
+
+        Returns:
+            {"data": [{"material", "scoring", "scoringPerFilter"}]} best first, or
+            {"data": "Exception: ..."} on failure.
+        )pbdoc",
+        py::arg("reference_core_material_json"), py::arg("temperature"),
+        py::arg("weights_json") = json::object(), py::arg("max_results") = 10);
+}
+
+} // namespace PyMKF

pyopenmagnetics-1.6.4/src/crossref.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "common.h"
+
+namespace PyMKF {
+
+// Core cross-referencer: given a reference core (shape + material + gapping) and
+// the operating conditions, rank alternatives that could replace it.
+json calculate_cross_referenced_core(json referenceCoreJson, json inputsJson,
+                                     int64_t referenceNumberTurns, json weightsJson,
+                                     int maximumNumberResults);
+
+// Core-material cross-referencer: rank materials that could replace a reference
+// material at a given temperature.
+json calculate_cross_referenced_core_material(json referenceCoreMaterialJson, double temperature,
+                                              json weightsJson, int maximumNumberResults);
+
+void register_crossref_bindings(py::module& m);
+
+} // namespace PyMKF

{pyopenmagnetics-1.6.3 → pyopenmagnetics-1.6.4}/src/losses.cpp

@@ -309,13 +309,19 @@ json get_available_core_losses_methods(json magneticJson) {
 json calculate_filling_factor(json coilJson) {
     try {
         OpenMagnetics::Coil coil(coilJson, false);
-        auto [areaFillingFactor, otherFactors] = coil.calculate_filling_factor();
-        auto [overlappingFillingFactor, contiguousFillingFactor] = otherFactors;
+        // MKF main changed Coil::calculate_filling_factor() from
+        // std::pair<double, std::pair<double,double>> to a named
+        // FillingFactorsOutput struct (area / maxLayer / overlapping /
+        // contiguous / windingFits). Read the members directly; keep the
+        // original three keys and add the two new members.
+        auto fillingFactors = coil.calculate_filling_factor();
 
         json result;
-        result["areaFillingFactor"] = areaFillingFactor;
-        result["overlappingFillingFactor"] = overlappingFillingFactor;
-        result["contiguousFillingFactor"] = contiguousFillingFactor;
+        result["areaFillingFactor"] = fillingFactors.areaFillingFactor;
+        result["overlappingFillingFactor"] = fillingFactors.overlappingFillingFactor;
+        result["contiguousFillingFactor"] = fillingFactors.contiguousFillingFactor;
+        result["maxLayerFillingFactor"] = fillingFactors.maxLayerFillingFactor;
+        result["windingFits"] = fillingFactors.windingFits;
         return result;
     }
     catch (const std::exception &exc) {

{pyopenmagnetics-1.6.3 → pyopenmagnetics-1.6.4}/src/module.cpp

@@ -5,6 +5,7 @@
 #include "bobbin.h"
 #include "winding.h"
 #include "advisers.h"
+#include "crossref.h"
 #include "converter.h"  // converter surface re-pointed at Kirchhoff api (converter.cpp shims)
 #include "cmc.h"  // CMC bindings re-pointed at Kirchhoff api::design_cmc (el-choker's path)
 #include "losses.h"
@@ -34,6 +35,7 @@ PYBIND11_MODULE(PyOpenMagnetics, m) {
     PyMKF::register_bobbin_bindings(m);
     PyMKF::register_winding_bindings(m);
     PyMKF::register_adviser_bindings(m);
+    PyMKF::register_crossref_bindings(m);  // core / core-material cross-referencers
     PyMKF::register_converter_bindings(m);  // converter surface via Kirchhoff
     PyMKF::register_cmc_bindings(m);  // CMC via Kirchhoff (calculate_cmc_inputs + advanced)
     PyMKF::register_losses_bindings(m);