PyOpenMagnetics 1.3.8__tar.gz → 1.3.10__tar.gz

{pyopenmagnetics-1.3.8 → pyopenmagnetics-1.3.10}/CMakeLists.txt

@@ -120,14 +120,25 @@ include_directories("${CMAKE_BINARY_DIR}/_deps/eigen-src")
 if(NOT LOCAL_MKF_MAS)
     message(STATUS "Fetching MKF")
     # Force fresh clone by using a unique timestamp - update this when MKF changes
-    set(MKF_FORCE_REFRESH "2025-02-26-01")
+    set(MKF_FORCE_REFRESH "2026-04-29-extra-components")
     # 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/EAS (added 2026-04 alongside the
+    # ExtraComponentsMode API). MAS is also a submodule of MKF but PyMKF
+    # fetches it independently below for fast-update reasons; CAS/EAS only
+    # exist as MKF submodules, so we need them populated under MKF/.
+    # NOTE: we cannot use GIT_SHALLOW with GIT_SUBMODULES — shallow clone
+    # skips submodule init. Drop the shallow flag for MKF so CAS/EAS/
+    # cci_coords are actually checked out. cci_coords MUST stay in this
+    # list — the CCI generator reads from MKF/cci_coords/coordinates/.
+    # MAS is fetched separately below (not a sub-fetch of MKF here) so
+    # leave it out, otherwise FetchContent doubles the clone.
     FetchContent_Declare(MKF
             GIT_REPOSITORY https://github.com/OpenMagnetics/MKF.git
             GIT_TAG main
             GIT_PROGRESS TRUE
-            GIT_SHALLOW TRUE)
+            GIT_SUBMODULES "CAS" "EAS" "cci_coords"
+            GIT_SUBMODULES_RECURSE TRUE)
 
     message(STATUS "Fetching mas")
     # Skip Git LFS to avoid bandwidth quota issues - data files are optional for build
@@ -237,6 +248,42 @@ add_custom_target(PyMASGeneration
                   /bin/echo "RUNNING PyMASGeneration"
                   DEPENDS "${MAS_DIRECTORY}/MAS.hpp")
 
+# ──────────────────────────────────────────────────────────────────
+# CAS.hpp generation (mirrors MKF/CMakeLists.txt:419-451)
+# CAS = Capacitor Adviser Schema. EAS = Element Adviser Schema.
+# Both are submodules of MKF (added 2026-04). MKF/Topology.h #includes
+# <CAS.hpp> for the get_extra_components_inputs API; we must generate
+# the header here so PyOpenMagnetics's TU sees it.
+# ──────────────────────────────────────────────────────────────────
+set(CAS_DIRECTORY "${CMAKE_BINARY_DIR}/CAS/")
+set(CAS_DIR "${MKF_DIR}/CAS")
+set(EAS_DIR "${MKF_DIR}/EAS")
+file(MAKE_DIRECTORY "${CAS_DIRECTORY}")
+
+add_custom_command(
+  OUTPUT "${CAS_DIRECTORY}/CAS.hpp"
+  COMMAND ${CMAKE_COMMAND} -E remove -f "${CAS_DIRECTORY}/CAS.hpp"
+  COMMAND quicktype -l c++ -s schema ${CAS_DIR}/schemas/inputs.json
+    -S ${CAS_DIR}/schemas/inputs/designRequirements.json
+    -S ${EAS_DIR}/schemas/utils.json
+    -S ${EAS_DIR}/schemas/inputs/twoTerminalOperatingPoint.json
+    -o ${CAS_DIRECTORY}/CAS.hpp --namespace CAS --source-style single-source
+    --type-style pascal-case --member-style underscore-case
+    --enumerator-style upper-underscore-case --no-boost
+    --top-level Inputs
+  DEPENDS
+    "${CAS_DIR}/schemas/inputs.json"
+    "${CAS_DIR}/schemas/inputs/designRequirements.json"
+    "${EAS_DIR}/schemas/utils.json"
+    "${EAS_DIR}/schemas/inputs/twoTerminalOperatingPoint.json"
+  USES_TERMINAL)
+
+add_custom_target(PyCASGeneration
+                  /bin/echo "RUNNING PyCASGeneration"
+                  DEPENDS "${CAS_DIRECTORY}/CAS.hpp")
+add_dependencies(PyCASGeneration PyMASGeneration)
+include_directories("${CAS_DIRECTORY}")
+
 message(STATUS "Compiling PyOpenMagnetics with modular structure")
 file(GLOB SOURCES src/*.cpp
     ${MKF_DIR}/src/*.cpp
@@ -247,11 +294,26 @@ file(GLOB SOURCES src/*.cpp
     ${MKF_DIR}/src/processors/*.cpp
     ${MKF_DIR}/src/support/*.cpp
     )
+
+set(CCI_GENERATED_CPP "${CMAKE_BINARY_DIR}/generated/CciCoordinatesData.cpp")
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
+add_custom_command(
+    OUTPUT "${CCI_GENERATED_CPP}"
+    COMMAND "${Python3_EXECUTABLE}"
+            "${MKF_DIR}/scripts/generate_cci_data.py"
+            "${MKF_DIR}/cci_coords"
+            "${CCI_GENERATED_CPP}"
+    DEPENDS "${MKF_DIR}/scripts/generate_cci_data.py"
+    COMMENT "Generating embedded CCI coordinates"
+    VERBATIM)
+add_custom_target(cci_data_gen DEPENDS "${CCI_GENERATED_CPP}")
+list(APPEND SOURCES "${CCI_GENERATED_CPP}")
+
 message(STATUS SOURCES)
 message(STATUS ${SOURCES})
 pybind11_add_module(PyOpenMagnetics ${SOURCES})
 
-add_dependencies(PyOpenMagnetics PyMASGeneration)
+add_dependencies(PyOpenMagnetics PyMASGeneration PyCASGeneration cci_data_gen)
 
 target_link_libraries(PyOpenMagnetics PUBLIC nlohmann_json::nlohmann_json levmar rapidfuzz::rapidfuzz)
 

{pyopenmagnetics-1.3.8 → pyopenmagnetics-1.3.10}/PKG-INFO

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

{pyopenmagnetics-1.3.8 → pyopenmagnetics-1.3.10}/pyproject.toml

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

{pyopenmagnetics-1.3.8 → pyopenmagnetics-1.3.10}/src/converter.cpp

@@ -629,6 +629,220 @@ json process_current_transformer(json ctJson, double turnsRatio, double secondar
     return process_converter("current_transformer", ctJson, true);
 }
 
+// ─────────────────────────────────────────────────────────────────────
+// get_extra_components_inputs (MKF 2026-04-29 API)
+//
+// Returns a JSON list describing the design requirements / operating
+// points of any extra components a topology brings along besides its
+// main magnetic — resonant tank caps for LLC, snubber nets, auxiliary
+// inductors, etc. The downstream caller can pipe each entry into a
+// component-search (TAS) or a fresh PyOM design call.
+//
+// Each list entry is one of:
+//   { "kind": "magnetic",  "inputs": { ...MAS::Inputs JSON... } }
+//   { "kind": "capacitor", "inputs": { ...CAS::Inputs JSON... } }
+//
+// Arguments:
+//   topology_name      — same key set as dispatch_converter (e.g. "llc",
+//                        "psfb", "active_clamp_forward").
+//   converter_json     — the converter spec used to construct the simple
+//                        topology class (NOT the AdvancedXxx version).
+//   mode               — "IDEAL" or "REAL". IDEAL returns archetypal
+//                        requirements without parasitics; REAL refines
+//                        with the main magnetic's actual leakage,
+//                        winding resistance, etc.
+//   magnetic_json      — optional MAS::Magnetic JSON, required by some
+//                        topologies in REAL mode. Pass null in IDEAL.
+// ─────────────────────────────────────────────────────────────────────
+
+namespace {
+
+// Construct the simple topology subclass (NOT AdvancedXxx), run the
+// design pipeline (process() / process_design_requirements()) so the
+// internal resonant-tank / extra-component values are populated, and
+// then invoke get_extra_components_inputs on it. The simple classes
+// own the design physics, so they're what the new API was designed
+// against. Some topologies require process() to have run first; we
+// invoke it via the SFINAE-detected member that exists on each.
+template <typename TopologyT>
+std::vector<std::variant<OpenMagnetics::Inputs, CAS::Inputs>>
+collect_extra_components(const json& converterJson,
+                         OpenMagnetics::ExtraComponentsMode mode,
+                         std::optional<OpenMagnetics::Magnetic> magnetic) {
+    TopologyT topology(converterJson);
+    topology._assertErrors = true;
+    // Run process() — the Topology base class entry point that wires
+    // process_design_requirements() + process_operating_points() and
+    // populates the internal Lr / Cr / inductance ratio that
+    // get_extra_components_inputs() reads. The Inputs return value is
+    // discarded; we only care about the side effects on `topology`.
+    topology.process();
+    return topology.get_extra_components_inputs(mode, magnetic);
+}
+
+std::vector<std::variant<OpenMagnetics::Inputs, CAS::Inputs>>
+dispatch_extra_components(const std::string& topologyName,
+                          const json& converterJson,
+                          OpenMagnetics::ExtraComponentsMode mode,
+                          std::optional<OpenMagnetics::Magnetic> magnetic) {
+    if (topologyName == "flyback")
+        return collect_extra_components<OpenMagnetics::Flyback>(converterJson, mode, magnetic);
+    if (topologyName == "buck")
+        return collect_extra_components<OpenMagnetics::Buck>(converterJson, mode, magnetic);
+    if (topologyName == "boost")
+        return collect_extra_components<OpenMagnetics::Boost>(converterJson, mode, magnetic);
+    if (topologyName == "single_switch_forward")
+        return collect_extra_components<OpenMagnetics::SingleSwitchForward>(converterJson, mode, magnetic);
+    if (topologyName == "two_switch_forward")
+        return collect_extra_components<OpenMagnetics::TwoSwitchForward>(converterJson, mode, magnetic);
+    if (topologyName == "active_clamp_forward")
+        return collect_extra_components<OpenMagnetics::ActiveClampForward>(converterJson, mode, magnetic);
+    if (topologyName == "push_pull")
+        return collect_extra_components<OpenMagnetics::PushPull>(converterJson, mode, magnetic);
+    if (topologyName == "llc")
+        return collect_extra_components<OpenMagnetics::Llc>(converterJson, mode, magnetic);
+    if (topologyName == "dab")
+        return collect_extra_components<OpenMagnetics::Dab>(converterJson, mode, magnetic);
+    if (topologyName == "phase_shifted_full_bridge" || topologyName == "psfb")
+        return collect_extra_components<OpenMagnetics::Psfb>(converterJson, mode, magnetic);
+    if (topologyName == "phase_shifted_half_bridge" || topologyName == "pshb")
+        return collect_extra_components<OpenMagnetics::Pshb>(converterJson, mode, magnetic);
+    if (topologyName == "cllc")
+        return collect_extra_components<OpenMagnetics::CllcConverter>(converterJson, mode, magnetic);
+    if (topologyName == "isolated_buck")
+        return collect_extra_components<OpenMagnetics::IsolatedBuck>(converterJson, mode, magnetic);
+    if (topologyName == "isolated_buck_boost")
+        return collect_extra_components<OpenMagnetics::IsolatedBuckBoost>(converterJson, mode, magnetic);
+    throw std::invalid_argument(
+        "get_extra_components_inputs: topology '" + topologyName +
+        "' has no extra-components dispatch (or hasn't been wired in PyMKF)."
+    );
+}
+
+}  // namespace
+
+// ─────────────────────────────────────────────────────────────────────
+// generate_ngspice_circuit (MKF native SPICE generator)
+//
+// Returns the canonical ngspice deck for a converter at a given operating
+// point, sized from the magnetic that was designed in Phase 3. This
+// replaces hand-rolled netlist templates on the Proteus side: MKF owns
+// the topology wiring (rectifier polarity, gate-drive timing, dead-time,
+// snubbers, K-coupling) so the simulation always validates the actual
+// designed magnetic.
+//
+// Args mirror the C++ method: turns_ratios (Np:Ns vector), magnetizing
+// inductance, optional vin / operating-point indices. The simple
+// topology class is constructed and process()'d first so internal state
+// (Lr / Cr for LLC, etc.) is populated before deck generation.
+// ─────────────────────────────────────────────────────────────────────
+namespace {
+// Isolated topologies (transformer): pass turns ratios + magnetizing inductance.
+template <typename TopologyT>
+std::string generate_spice_isolated(const json& converterJson,
+                                     const std::vector<double>& turnsRatios,
+                                     double magnetizingInductance,
+                                     size_t vinIdx, size_t opIdx) {
+    TopologyT topology(converterJson);
+    topology._assertErrors = true;
+    topology.process();
+    return topology.generate_ngspice_circuit(turnsRatios, magnetizingInductance, vinIdx, opIdx);
+}
+
+// Non-isolated topologies (single inductor): just pass the inductance.
+template <typename TopologyT>
+std::string generate_spice_inductor(const json& converterJson,
+                                     double inductance,
+                                     size_t vinIdx, size_t opIdx) {
+    TopologyT topology(converterJson);
+    topology._assertErrors = true;
+    topology.process();
+    return topology.generate_ngspice_circuit(inductance, vinIdx, opIdx);
+}
+
+}  // namespace
+
+json generate_ngspice_circuit(const std::string& topologyName,
+                              json converterJson,
+                              std::vector<double> turnsRatios,
+                              double magnetizingInductance,
+                              size_t vinIdx,
+                              size_t opIdx) {
+    try {
+        std::string spice;
+        // Non-isolated single-inductor topologies — magnetizingInductance
+        // arg is interpreted as the main inductor value.
+        if (topologyName == "buck")
+            spice = generate_spice_inductor<OpenMagnetics::Buck>(converterJson, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "boost")
+            spice = generate_spice_inductor<OpenMagnetics::Boost>(converterJson, magnetizingInductance, vinIdx, opIdx);
+        // Isolated topologies — turnsRatios + magnetizing inductance.
+        else if (topologyName == "flyback") spice = generate_spice_isolated<OpenMagnetics::Flyback>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "single_switch_forward") spice = generate_spice_isolated<OpenMagnetics::SingleSwitchForward>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "two_switch_forward")    spice = generate_spice_isolated<OpenMagnetics::TwoSwitchForward>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "active_clamp_forward")  spice = generate_spice_isolated<OpenMagnetics::ActiveClampForward>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "push_pull") spice = generate_spice_isolated<OpenMagnetics::PushPull>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "llc")       spice = generate_spice_isolated<OpenMagnetics::Llc>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        // CLLC is intentionally not wired here yet — its
+        // generate_ngspice_circuit signature takes (double turnsRatio,
+        // CllcResonantParameters&, ...), which doesn't fit the uniform
+        // (vector<double> turnsRatios, double Lm, ...) shape used by every
+        // other topology. Add a separate dispatch path when we need it.
+        else if (topologyName == "dab")       spice = generate_spice_isolated<OpenMagnetics::Dab>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "phase_shifted_full_bridge" || topologyName == "psfb") spice = generate_spice_isolated<OpenMagnetics::Psfb>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "phase_shifted_half_bridge" || topologyName == "pshb") spice = generate_spice_isolated<OpenMagnetics::Pshb>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "isolated_buck")       spice = generate_spice_isolated<OpenMagnetics::IsolatedBuck>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else if (topologyName == "isolated_buck_boost") spice = generate_spice_isolated<OpenMagnetics::IsolatedBuckBoost>(converterJson, turnsRatios, magnetizingInductance, vinIdx, opIdx);
+        else return json{{"error", "generate_ngspice_circuit: unknown topology '" + topologyName + "'"}};
+        return json{{"netlist", spice}};
+    } catch (const std::exception& exc) {
+        return json{{"error", std::string("generate_ngspice_circuit: ") + exc.what()}};
+    }
+}
+
+json get_extra_components_inputs(const std::string& topologyName,
+                                 json converterJson,
+                                 const std::string& modeStr,
+                                 json magneticJson) {
+    try {
+        OpenMagnetics::ExtraComponentsMode mode;
+        if (modeStr == "IDEAL" || modeStr == "ideal")
+            mode = OpenMagnetics::ExtraComponentsMode::IDEAL;
+        else if (modeStr == "REAL" || modeStr == "real")
+            mode = OpenMagnetics::ExtraComponentsMode::REAL;
+        else
+            return json{{"error", "mode must be 'IDEAL' or 'REAL', got: " + modeStr}};
+
+        std::optional<OpenMagnetics::Magnetic> magnetic;
+        if (!magneticJson.is_null()) {
+            magnetic = OpenMagnetics::Magnetic(magneticJson);
+        }
+
+        auto components = dispatch_extra_components(topologyName, converterJson, mode, magnetic);
+
+        json out = json::array();
+        for (const auto& comp : components) {
+            json entry;
+            std::visit([&entry](const auto& inputs) {
+                using T = std::decay_t<decltype(inputs)>;
+                json inputsJson;
+                to_json(inputsJson, inputs);
+                if constexpr (std::is_same_v<T, OpenMagnetics::Inputs>) {
+                    entry["kind"] = "magnetic";
+                } else {
+                    // CAS::Inputs
+                    entry["kind"] = "capacitor";
+                }
+                entry["inputs"] = inputsJson;
+            }, comp);
+            out.push_back(entry);
+        }
+        return out;
+    } catch (const std::exception& exc) {
+        return json{{"error", std::string("get_extra_components_inputs: ") + exc.what()}};
+    }
+}
+
 void register_converter_bindings(py::module& m) {
     m.def("process_converter", &process_converter,
         "Process a converter topology specification to Inputs.",
@@ -651,6 +865,27 @@ void register_converter_bindings(py::module& m) {
     m.def("process_isolated_buck_boost", &process_isolated_buck_boost, "Process Isolated Buck-Boost.", py::arg("isolated_buck_boost"));
     m.def("process_current_transformer", &process_current_transformer, "Process Current Transformer.",
         py::arg("ct"), py::arg("turns_ratio"), py::arg("secondary_resistance") = 0.0);
+
+    m.def("generate_ngspice_circuit", &generate_ngspice_circuit,
+        "Return the canonical ngspice SPICE deck for the topology at a "
+        "given operating point, sized from the magnetic design (turns "
+        "ratios + magnetizing inductance). Wrapper around each Topology "
+        "subclass's generate_ngspice_circuit method; processes the "
+        "topology first so internal state (Lr/Cr for LLC, etc.) is "
+        "populated. Returns {'netlist': '<spice>'} or {'error': '...'}.",
+        py::arg("topology_name"), py::arg("converter_json"),
+        py::arg("turns_ratios"), py::arg("magnetizing_inductance"),
+        py::arg("vin_index") = 0, py::arg("op_index") = 0);
+
+    m.def("get_extra_components_inputs", &get_extra_components_inputs,
+        "Return the design requirements for extra components a topology brings "
+        "alongside its main magnetic — resonant tank Lr/Cr for LLC, snubber "
+        "components for PSFB, etc. Each entry is {kind: 'magnetic'|'capacitor', "
+        "inputs: <MAS or CAS Inputs JSON>}. Mode 'IDEAL' returns archetypal "
+        "requirements; 'REAL' refines using the supplied main magnetic's "
+        "leakage / DCR / etc.",
+        py::arg("topology_name"), py::arg("converter_json"),
+        py::arg("mode") = "IDEAL", py::arg("magnetic_json") = nullptr);
 }
 
 } // namespace PyMKF