PyOpenMagnetics 1.4.6__tar.gz → 1.5.1__tar.gz

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/CMakeLists.txt

@@ -218,7 +218,15 @@ add_custom_command(
   OUTPUT "${MAS_DIRECTORY}/MAS.hpp"
   # Force regeneration by removing output first
   COMMAND ${CMAKE_COMMAND} -E remove -f ${MAS_DIRECTORY}/MAS.hpp
-  COMMAND quicktype -l c++ -s schema ${MAS_DIR}/schemas/MAS.json 
+  COMMAND quicktype -l c++ -s schema ${MAS_DIR}/schemas/MAS.json
+    # PEAS schemas: MAS main ($id https://psma.com/mas/...) now $refs shared
+    # PEAS primitives (https://psma.com/peas/...). quicktype resolves those
+    # external $refs by $id from sources passed with -S, so the PEAS schemas
+    # must be fed in here. PEAS is an MKF submodule at ${MKF_DIR}/PEAS.
+    -S ${MKF_DIR}/PEAS/schemas/utils.json
+    -S ${MKF_DIR}/PEAS/schemas/inputs/operatingPointExcitation.json
+    -S ${MKF_DIR}/PEAS/schemas/outputs/insulationCoordination.json
+    -S ${MKF_DIR}/PEAS/schemas/outputs/lossElementPerHarmonic.json
     -S ${MAS_DIR}/schemas/magnetic.json
     -S ${MAS_DIR}/schemas/magnetic/core.json
     -S ${MAS_DIR}/schemas/magnetic/coil.json

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/PKG-INFO

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

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/examples/complete_simulation_example.py

@@ -179,8 +179,7 @@ def simulate_losses(magnetic, specs):
     print("\n[1] Calculating core losses...")
     models = {
         "coreLosses": "IGSE",
-        "reluctance": "ZHANG",
-        "coreTemperature": "MANIKTALA"
+        "reluctance": "ZHANG"
     }
     
     try:

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/examples/flyback_220v_12v_1a.py

@@ -287,8 +287,7 @@ def design_flyback_transformer():
     
     models = {
         "coreLosses": "IGSE",
-        "reluctance": "ZHANG",
-        "coreTemperature": "MANIKTALA"
+        "reluctance": "ZHANG"
     }
     
     best_design = None

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/examples/flyback_220v_12v_2a_complete.py

@@ -301,8 +301,7 @@ def design_flyback_transformer():
     
     models = {
         "coreLosses": "IGSE",
-        "reluctance": "ZHANG",
-        "coreTemperature": "MANIKTALA"
+        "reluctance": "ZHANG"
     }
     
     best_design = None

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/examples/flyback_design.py

@@ -127,8 +127,7 @@ def design_flyback_transformer():
     
     models = {
         "coreLosses": "IGSE",
-        "reluctance": "ZHANG",
-        "coreTemperature": "MANIKTALA"
+        "reluctance": "ZHANG"
     }
     
     for i, item in enumerate(magnetics):

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/pyproject.toml

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

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/src/converter.cpp

@@ -149,7 +149,75 @@ static std::string normalize_topology_name(const std::string& s) {
     return s;
 }
 
+// ─────────────────────────────────────────────────────────────────────
+// Base-spec fast path (ABT #11)
+//
+// The fast path normally constructs an Advanced* converter whose from_json
+// hard-requires `desiredInductance` (e.g. AdvancedBuck, MKF Buck.h:219). A
+// caller passing a BASE spec (operating point + currentRippleRatio, no
+// desiredInductance) would otherwise get
+// `[json.exception.out_of_range.403] key 'desiredInductance' not found`.
+//
+// When `desiredInductance` is absent we instead construct the BASE converter
+// class, whose virtual process_design_requirements() DERIVES the inductance
+// from the operating points + currentRippleRatio (or maximumSwitchCurrent) —
+// the same MKF math the slow path uses. No L-derivation is duplicated here;
+// it all stays in MKF (house rule). If neither desiredInductance nor a ripple
+// driver is present, the base class throws a loud, specific exception rather
+// than substituting a default.
+//
+// Two helpers cover the two simulate signatures: single-inductor topologies
+// (Buck/Boost/Cuk/…) take a scalar inductance; transformer topologies
+// (Flyback/Forward family/IsolatedBuck/…) take (turnsRatios, inductance).
+// ─────────────────────────────────────────────────────────────────────
+template <typename BaseConverter>
+OpenMagnetics::Inputs process_base_spec_scalar_L(const json& converterJson, bool useNgspice, MAS::Topologies topology) {
+    BaseConverter converter(converterJson);
+    converter._assertErrors = true;
+    if (useNgspice) {
+        auto designReqs = converter.process_design_requirements();
+        double inductance = OpenMagnetics::resolve_dimensional_values(designReqs.get_magnetizing_inductance());
+        auto operatingPoints = converter.simulate_and_extract_operating_points(inductance);
+        OpenMagnetics::Inputs result;
+        result.set_design_requirements(designReqs);
+        result.set_operating_points(operatingPoints);
+        result.get_mutable_design_requirements().set_topology(topology);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(topology);
+        return result;
+    }
+}
+
+template <typename BaseConverter>
+OpenMagnetics::Inputs process_base_spec_vector_L(const json& converterJson, bool useNgspice, MAS::Topologies topology) {
+    BaseConverter converter(converterJson);
+    converter._assertErrors = true;
+    if (useNgspice) {
+        auto designReqs = converter.process_design_requirements();
+        std::vector<double> turnsRatios;
+        for (const auto& tr : designReqs.get_turns_ratios()) {
+            turnsRatios.push_back(OpenMagnetics::resolve_dimensional_values(tr));
+        }
+        double inductance = OpenMagnetics::resolve_dimensional_values(designReqs.get_magnetizing_inductance());
+        auto operatingPoints = converter.simulate_and_extract_operating_points(turnsRatios, inductance);
+        OpenMagnetics::Inputs result;
+        result.set_design_requirements(designReqs);
+        result.set_operating_points(operatingPoints);
+        result.get_mutable_design_requirements().set_topology(topology);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(topology);
+        return result;
+    }
+}
+
 OpenMagnetics::Inputs process_flyback_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_vector_L<OpenMagnetics::Flyback>(converterJson, useNgspice, MAS::Topologies::FLYBACK_CONVERTER);
+    }
     OpenMagnetics::AdvancedFlyback converter(converterJson);
     converter._assertErrors = true;
     
@@ -184,6 +252,9 @@ OpenMagnetics::Inputs process_flyback_internal(const json& converterJson, bool u
 }
 
 OpenMagnetics::Inputs process_buck_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_scalar_L<OpenMagnetics::Buck>(converterJson, useNgspice, MAS::Topologies::BUCK_CONVERTER);
+    }
     OpenMagnetics::AdvancedBuck converter(converterJson);
     converter._assertErrors = true;
     
@@ -204,6 +275,9 @@ OpenMagnetics::Inputs process_buck_internal(const json& converterJson, bool useN
 }
 
 OpenMagnetics::Inputs process_boost_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_scalar_L<OpenMagnetics::Boost>(converterJson, useNgspice, MAS::Topologies::BOOST_CONVERTER);
+    }
     OpenMagnetics::AdvancedBoost converter(converterJson);
     converter._assertErrors = true;
     
@@ -224,6 +298,9 @@ OpenMagnetics::Inputs process_boost_internal(const json& converterJson, bool use
 }
 
 OpenMagnetics::Inputs process_single_switch_forward_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_vector_L<OpenMagnetics::SingleSwitchForward>(converterJson, useNgspice, MAS::Topologies::SINGLE_SWITCH_FORWARD_CONVERTER);
+    }
     OpenMagnetics::AdvancedSingleSwitchForward converter(converterJson);
     converter._assertErrors = true;
     
@@ -248,6 +325,9 @@ OpenMagnetics::Inputs process_single_switch_forward_internal(const json& convert
 }
 
 OpenMagnetics::Inputs process_two_switch_forward_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_vector_L<OpenMagnetics::TwoSwitchForward>(converterJson, useNgspice, MAS::Topologies::TWO_SWITCH_FORWARD_CONVERTER);
+    }
     OpenMagnetics::AdvancedTwoSwitchForward converter(converterJson);
     converter._assertErrors = true;
     
@@ -272,6 +352,9 @@ OpenMagnetics::Inputs process_two_switch_forward_internal(const json& converterJ
 }
 
 OpenMagnetics::Inputs process_active_clamp_forward_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_vector_L<OpenMagnetics::ActiveClampForward>(converterJson, useNgspice, MAS::Topologies::ACTIVE_CLAMP_FORWARD_CONVERTER);
+    }
     OpenMagnetics::AdvancedActiveClampForward converter(converterJson);
     converter._assertErrors = true;
     
@@ -296,6 +379,9 @@ OpenMagnetics::Inputs process_active_clamp_forward_internal(const json& converte
 }
 
 OpenMagnetics::Inputs process_push_pull_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_vector_L<OpenMagnetics::PushPull>(converterJson, useNgspice, MAS::Topologies::PUSH_PULL_CONVERTER);
+    }
     OpenMagnetics::AdvancedPushPull converter(converterJson);
     converter._assertErrors = true;
     
@@ -428,6 +514,9 @@ OpenMagnetics::Inputs process_pshb_internal(const json& converterJson, bool useN
 }
 
 OpenMagnetics::Inputs process_isolated_buck_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_vector_L<OpenMagnetics::IsolatedBuck>(converterJson, useNgspice, MAS::Topologies::ISOLATED_BUCK_CONVERTER);
+    }
     OpenMagnetics::AdvancedIsolatedBuck converter(converterJson);
     converter._assertErrors = true;
     
@@ -452,6 +541,9 @@ OpenMagnetics::Inputs process_isolated_buck_internal(const json& converterJson,
 }
 
 OpenMagnetics::Inputs process_isolated_buck_boost_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_vector_L<OpenMagnetics::IsolatedBuckBoost>(converterJson, useNgspice, MAS::Topologies::ISOLATED_BUCK_BOOST_CONVERTER);
+    }
     OpenMagnetics::AdvancedIsolatedBuckBoost converter(converterJson);
     converter._assertErrors = true;
     
@@ -511,6 +603,9 @@ OpenMagnetics::Inputs process_pfc_internal(const json& converterJson) {
 // ─────────────────────────────────────────────────────────────────────
 
 OpenMagnetics::Inputs process_cuk_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_scalar_L<OpenMagnetics::Cuk>(converterJson, useNgspice, MAS::Topologies::CUK_CONVERTER);
+    }
     OpenMagnetics::AdvancedCuk converter(converterJson);
     converter._assertErrors = true;
     if (useNgspice) {
@@ -530,6 +625,9 @@ OpenMagnetics::Inputs process_cuk_internal(const json& converterJson, bool useNg
 }
 
 OpenMagnetics::Inputs process_sepic_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_scalar_L<OpenMagnetics::Sepic>(converterJson, useNgspice, MAS::Topologies::SEPIC_CONVERTER);
+    }
     OpenMagnetics::AdvancedSepic converter(converterJson);
     converter._assertErrors = true;
     if (useNgspice) {
@@ -549,6 +647,9 @@ OpenMagnetics::Inputs process_sepic_internal(const json& converterJson, bool use
 }
 
 OpenMagnetics::Inputs process_zeta_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_scalar_L<OpenMagnetics::Zeta>(converterJson, useNgspice, MAS::Topologies::ZETA_CONVERTER);
+    }
     OpenMagnetics::AdvancedZeta converter(converterJson);
     converter._assertErrors = true;
     if (useNgspice) {
@@ -568,6 +669,9 @@ OpenMagnetics::Inputs process_zeta_internal(const json& converterJson, bool useN
 }
 
 OpenMagnetics::Inputs process_four_switch_buck_boost_internal(const json& converterJson, bool useNgspice) {
+    if (!converterJson.contains("desiredInductance")) {
+        return process_base_spec_scalar_L<OpenMagnetics::FourSwitchBuckBoost>(converterJson, useNgspice, MAS::Topologies::FOUR_SWITCH_BUCK_BOOST_CONVERTER);
+    }
     OpenMagnetics::AdvancedFourSwitchBuckBoost converter(converterJson);
     converter._assertErrors = true;
     if (useNgspice) {
@@ -610,6 +714,35 @@ OpenMagnetics::Inputs process_asymmetric_half_bridge_internal(const json& conver
 }
 
 OpenMagnetics::Inputs process_weinberg_internal(const json& converterJson, bool useNgspice) {
+    // Base-spec fast path (ABT #11): derive L from the base Weinberg when no
+    // desiredInductance is supplied. Inlined (not via the shared helper)
+    // because Weinberg's simulate signature takes a SCALAR turns ratio
+    // (single-secondary topology), not the vector the other transformers use.
+    if (!converterJson.contains("desiredInductance")) {
+        OpenMagnetics::Weinberg converter(converterJson);
+        converter._assertErrors = true;
+        if (useNgspice) {
+            auto designReqs = converter.process_design_requirements();
+            std::vector<double> turnsRatios;
+            for (const auto& tr : designReqs.get_turns_ratios()) {
+                turnsRatios.push_back(OpenMagnetics::resolve_dimensional_values(tr));
+            }
+            if (turnsRatios.empty()) {
+                throw std::runtime_error("Weinberg converter requires at least one turns ratio");
+            }
+            double inductance = OpenMagnetics::resolve_dimensional_values(designReqs.get_magnetizing_inductance());
+            auto operatingPoints = converter.simulate_and_extract_operating_points(turnsRatios[0], inductance);
+            OpenMagnetics::Inputs result;
+            result.set_design_requirements(designReqs);
+            result.set_operating_points(operatingPoints);
+            result.get_mutable_design_requirements().set_topology(MAS::Topologies::WEINBERG_CONVERTER);
+            return result;
+        } else {
+            OpenMagnetics::Inputs result = converter.process();
+            result.get_mutable_design_requirements().set_topology(MAS::Topologies::WEINBERG_CONVERTER);
+            return result;
+        }
+    }
     OpenMagnetics::AdvancedWeinberg converter(converterJson);
     converter._assertErrors = true;
     if (useNgspice) {
@@ -788,16 +921,50 @@ json process_converter(const std::string& topologyName, json converterJson, bool
     return process_converter_internal(normalized, converterJson, useNgspice);
 }
 
+// Build candidate magnetics from a converter object via the MKF template
+// method, threading the `fast` flag (fast core-only adviser vs full
+// winding+simulation adviser) and optional per-filter weights.
+template <typename ConverterType>
+static std::vector<std::pair<OpenMagnetics::Mas, double>> advise_from_converter_spec(
+        const json& converterJson, bool fast,
+        const std::map<OpenMagnetics::MagneticFilters, double>& weights,
+        int maxResults, OpenMagnetics::MagneticAdviser& adviser) {
+    ConverterType converter(converterJson);
+    converter._assertErrors = true;
+    return weights.empty()
+        ? adviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+        : adviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
+}
+
+// Single-inductor, non-isolated family (Buck/Boost/Cuk/Sepic/Zeta/
+// FourSwitchBuckBoost). Their Advanced* class requires ONLY desiredInductance
+// on top of a plain converter spec, so we pick the model purely on the
+// presence of that key: Advanced* when the user pins L (honoured as the
+// nominal target), Base when absent (L derived from the ripple budget in
+// MKF). Transformer/resonant families do NOT get this duality — their
+// Advanced* from_json also requires desiredTurnsRatios (Flyback also
+// desiredDutyCycle), i.e. design *outputs* a converter spec does not carry —
+// so they always use the Base model, which derives turns + L itself.
+template <typename Base, typename Advanced>
+static std::vector<std::pair<OpenMagnetics::Mas, double>> advise_inductor_family(
+        const json& converterJson, bool fast,
+        const std::map<OpenMagnetics::MagneticFilters, double>& weights,
+        int maxResults, OpenMagnetics::MagneticAdviser& adviser) {
+    return converterJson.contains("desiredInductance")
+        ? advise_from_converter_spec<Advanced>(converterJson, fast, weights, maxResults, adviser)
+        : advise_from_converter_spec<Base>(converterJson, fast, weights, maxResults, adviser);
+}
+
 // Simplified design_magnetics_from_converter using MKF template method
 json design_magnetics_from_converter(
     const std::string& topologyNameRaw,
-    json converterJson, 
-    int maxResults, 
-    json coreModeJson, 
-    bool useNgspice, 
-    json weightsJson) {
-    
-    (void)useNgspice;  // Template method always uses ngspice
+    json converterJson,
+    int maxResults,
+    json coreModeJson,
+    bool useNgspice,
+    json weightsJson,
+    bool fast) {
+
 
     // Accept MAS 1.0 camelCase, pre-1.0 Title Case, or internal short form.
     const std::string topologyName = normalize_topology_name(topologyNameRaw);
@@ -821,125 +988,109 @@ json design_magnetics_from_converter(
         
         std::vector<std::pair<OpenMagnetics::Mas, double>> masMagnetics;
         
-        // Use MKF template method - handles all converters automatically.
-        // For Buck / Boost the basic process_design_requirements() sets
-        // only `magnetizingInductance.minimum` (a ripple-floor), and
-        // the CoreAdviser picks the smallest core satisfying it
-        // regardless of the L the user asked for. Dispatch to the
-        // Advanced* subclass so spec.desiredInductance becomes the
-        // nominal target (AdvancedBuck/Boost::process_design_requirements
-        // override does this, MKF commit 8acd72c7).
+        // Build candidate magnetics from the converter spec via the MKF
+        // template method. Two independent axes (4 behaviours total):
         //
-        // Flyback stays on the basic ctor: AdvancedFlyback's from_json
-        // requires extra fields (desiredDutyCycle, desiredTurnsRatios)
-        // that aren't in a normal converter spec. The basic
-        // Flyback::process_design_requirements already sets nominal
-        // from its V·s + duty-cycle derivation, so the magnetic gets
-        // sized correctly without the Advanced* path.
+        //   * Base vs Advanced* model — chosen PER TOPOLOGY:
+        //       - Single-inductor family (Buck/Boost/Cuk/Sepic/Zeta/
+        //         FourSwitchBuckBoost): advise_inductor_family() picks
+        //         Advanced* when desiredInductance is present (honoured as the
+        //         nominal L target), Base otherwise (L derived from the ripple
+        //         budget). This is ABT #11 — the slow path used to force
+        //         Advanced for Buck/Boost and throw on a base spec.
+        //       - Transformer/resonant families: always Base. Their Advanced*
+        //         from_json requires desiredTurnsRatios (Flyback also
+        //         desiredDutyCycle) — design outputs a converter spec lacks —
+        //         so only Base is constructible; it derives turns + L itself.
+        //   * fast flag — fast core-only adviser vs full winding+sim adviser,
+        //     threaded into get_advised_magnetic_from_converter for every
+        //     topology.
         if (topologyName == "flyback" || topologyName == "advanced_flyback") {
             OpenMagnetics::Flyback converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "buck" || topologyName == "advanced_buck") {
-            OpenMagnetics::AdvancedBuck converter(converterJson);
-            converter._assertErrors = true;
-            masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+            masMagnetics = advise_inductor_family<OpenMagnetics::Buck, OpenMagnetics::AdvancedBuck>(
+                converterJson, fast, weights, maxResults, magneticAdviser);
         }
         else if (topologyName == "boost" || topologyName == "advanced_boost") {
-            OpenMagnetics::AdvancedBoost converter(converterJson);
-            converter._assertErrors = true;
-            masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+            masMagnetics = advise_inductor_family<OpenMagnetics::Boost, OpenMagnetics::AdvancedBoost>(
+                converterJson, fast, weights, maxResults, magneticAdviser);
         }
         else if (topologyName == "single_switch_forward") {
             OpenMagnetics::SingleSwitchForward converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "two_switch_forward") {
             OpenMagnetics::TwoSwitchForward converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "active_clamp_forward") {
             OpenMagnetics::ActiveClampForward converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "push_pull") {
             OpenMagnetics::PushPull converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "isolated_buck") {
             OpenMagnetics::IsolatedBuck converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "isolated_buck_boost") {
             OpenMagnetics::IsolatedBuckBoost converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "llc" || topologyName == "advanced_llc") {
             OpenMagnetics::Llc converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "cuk" || topologyName == "advanced_cuk") {
-            OpenMagnetics::Cuk converter(converterJson);
-            converter._assertErrors = true;
-            masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+            masMagnetics = advise_inductor_family<OpenMagnetics::Cuk, OpenMagnetics::AdvancedCuk>(
+                converterJson, fast, weights, maxResults, magneticAdviser);
         }
         else if (topologyName == "sepic" || topologyName == "advanced_sepic") {
-            OpenMagnetics::Sepic converter(converterJson);
-            converter._assertErrors = true;
-            masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+            masMagnetics = advise_inductor_family<OpenMagnetics::Sepic, OpenMagnetics::AdvancedSepic>(
+                converterJson, fast, weights, maxResults, magneticAdviser);
         }
         else if (topologyName == "zeta" || topologyName == "advanced_zeta") {
-            OpenMagnetics::Zeta converter(converterJson);
-            converter._assertErrors = true;
-            masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+            masMagnetics = advise_inductor_family<OpenMagnetics::Zeta, OpenMagnetics::AdvancedZeta>(
+                converterJson, fast, weights, maxResults, magneticAdviser);
         }
         else if (topologyName == "four_switch_buck_boost" || topologyName == "advanced_four_switch_buck_boost") {
-            OpenMagnetics::FourSwitchBuckBoost converter(converterJson);
-            converter._assertErrors = true;
-            masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+            masMagnetics = advise_inductor_family<OpenMagnetics::FourSwitchBuckBoost, OpenMagnetics::AdvancedFourSwitchBuckBoost>(
+                converterJson, fast, weights, maxResults, magneticAdviser);
         }
         else if (topologyName == "asymmetric_half_bridge" || topologyName == "advanced_asymmetric_half_bridge") {
             OpenMagnetics::AsymmetricHalfBridge converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "phase_shifted_full_bridge" || topologyName == "psfb" ||
                  topologyName == "advanced_phase_shifted_full_bridge" || topologyName == "advanced_psfb") {
@@ -952,36 +1103,36 @@ json design_magnetics_from_converter(
             OpenMagnetics::Psfb converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "weinberg" || topologyName == "advanced_weinberg") {
             OpenMagnetics::Weinberg converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "vienna" || topologyName == "advanced_vienna") {
             OpenMagnetics::Vienna converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "clllc" || topologyName == "advanced_clllc") {
             OpenMagnetics::Clllc converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "src" || topologyName == "advanced_src") {
             OpenMagnetics::Src converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else if (topologyName == "dab" || topologyName == "advanced_dab" ||
                  topologyName == "dual_active_bridge") {
@@ -992,18 +1143,26 @@ json design_magnetics_from_converter(
             OpenMagnetics::Dab converter(converterJson);
             converter._assertErrors = true;
             masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults)
-                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults);
+                ? magneticAdviser.get_advised_magnetic_from_converter(converter, maxResults, fast)
+                : magneticAdviser.get_advised_magnetic_from_converter(converter, weights, maxResults, fast);
         }
         else {
-            // Fall back to old approach for other topologies
+            // Fall back for topologies without a converter-model adviser path
+            // (e.g. PFC, current transformer). dispatch_converter / the
+            // process_*_internal it calls already pick Base vs Advanced on the
+            // presence of desiredInductance (ABT #11), so the Base/Advanced
+            // behaviour is preserved here too; only the adviser stage differs.
             json inputsJson = process_converter_internal(topologyName, converterJson, useNgspice);
             if (inputsJson.contains("error")) return inputsJson;
-            
+
             OpenMagnetics::Inputs inputs(inputsJson);
-            masMagnetics = weights.empty()
-                ? magneticAdviser.get_advised_magnetic(inputs, maxResults)
-                : magneticAdviser.get_advised_magnetic(inputs, weights, maxResults);
+            if (fast) {
+                masMagnetics = magneticAdviser.get_advised_magnetic_fast(inputs, maxResults);
+            } else if (weights.empty()) {
+                masMagnetics = magneticAdviser.get_advised_magnetic(inputs, maxResults);
+            } else {
+                masMagnetics = magneticAdviser.get_advised_magnetic(inputs, weights, maxResults);
+            }
         }
         
         // Build results (same as before)
@@ -3944,9 +4103,10 @@ void register_converter_bindings(py::module& m) {
     
     m.def("design_magnetics_from_converter", &design_magnetics_from_converter,
         "Design magnetic components from a converter specification.",
-        py::arg("topology_name"), py::arg("converter_json"), 
+        py::arg("topology_name"), py::arg("converter_json"),
         py::arg("max_results") = 1, py::arg("core_mode_json") = "available cores",
-        py::arg("use_ngspice") = true, py::arg("weights_json") = nullptr);
+        py::arg("use_ngspice") = true, py::arg("weights_json") = nullptr,
+        py::arg("fast") = false);
     
     m.def("process_flyback", &process_flyback, "Process Flyback converter.", py::arg("flyback"));
     m.def("process_buck", &process_buck, "Process Buck converter.", py::arg("buck"));

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/src/converter.h

@@ -9,12 +9,13 @@ json process_converter(const std::string& topologyName, json converterJson, bool
 
 // Combined endpoint: converter -> magnetic designs
 json design_magnetics_from_converter(
-    const std::string& topologyName, 
-    json converterJson, 
-    int maxResults, 
-    json coreModeJson, 
-    bool useNgspice = true, 
-    json weightsJson = nullptr);
+    const std::string& topologyName,
+    json converterJson,
+    int maxResults,
+    json coreModeJson,
+    bool useNgspice = true,
+    json weightsJson = nullptr,
+    bool fast = false);
 
 // Per-topology thin wrappers (from .pyi stubs)
 json process_flyback(json flybackJson);

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/src/core.cpp

@@ -430,6 +430,70 @@ double calculate_saturation_current_at_operating_point(
     return magnetic.calculate_saturation_current(op, temperature);
 }
 
+double calculate_peak_winding_current(json magneticJson, json operatingPointJson, int windingIndex) {
+    OpenMagnetics::Magnetic magnetic(magneticJson);
+    MAS::OperatingPoint op;
+    from_json(operatingPointJson, op);
+
+    // Operating-point magnetizing inductance of the as-designed magnetic
+    // (gapped circuit + DC-bias rolloff). Same L the saturation-current
+    // accessor uses, so I_peak and I_sat stay on a consistent footing.
+    OpenMagnetics::MagnetizingInductance magnetizingInductanceCalc;
+    auto inductanceOutput =
+        magnetizingInductanceCalc.calculate_inductance_from_number_turns_and_gapping(
+            magnetic.get_mutable_core(), magnetic.get_mutable_coil(), &op);
+    auto inductanceNominal = inductanceOutput.get_magnetizing_inductance().get_nominal();
+    if (!inductanceNominal.has_value() || inductanceNominal.value() <= 0) {
+        throw std::runtime_error(
+            "calculate_peak_winding_current: operating-point magnetizing "
+            "inductance is missing or non-positive — cannot derive the "
+            "magnetizing current.");
+    }
+    double magnetizingInductance = inductanceNominal.value();
+
+    auto excitations = op.get_mutable_excitations_per_winding();
+    if (excitations.empty()) {
+        throw std::runtime_error(
+            "calculate_peak_winding_current: operating point has no winding "
+            "excitations.");
+    }
+
+    // The magnetizing (flux-driving) current is referred to the primary
+    // (winding 0): I_mag = (1/L) ∫ v_primary dt, derived from the primary
+    // excitation's voltage. addOffset=true folds the operating DC bias of
+    // the primary current back in, so the returned peak is the saturation-
+    // driving peak (DC + ripple), not just the AC ripple amplitude.
+    auto primaryExcitation = excitations[0];
+    auto magnetizingCurrent = OpenMagnetics::Inputs::calculate_magnetizing_current(
+        primaryExcitation, magnetizingInductance, true, true);
+    auto processed = magnetizingCurrent.get_processed();
+    if (!processed.has_value() || !processed->get_peak().has_value()) {
+        throw std::runtime_error(
+            "calculate_peak_winding_current: computed magnetizing current has "
+            "no processed peak.");
+    }
+    double primaryPeak = processed->get_peak().value();
+
+    if (windingIndex == 0) {
+        return primaryPeak;
+    }
+
+    // Saturation is a single-flux core property; the magnetizing current
+    // referred to winding i is the primary-referred value scaled by the
+    // turns ratio: I_mag_i = I_mag_0 · N_0 / N_i.
+    double numberTurnsPrimary =
+        static_cast<double>(magnetic.get_mutable_coil().get_number_turns(0));
+    double numberTurnsWinding =
+        static_cast<double>(magnetic.get_mutable_coil().get_number_turns(windingIndex));
+    if (numberTurnsWinding <= 0) {
+        throw std::runtime_error(
+            "calculate_peak_winding_current: winding " +
+            std::to_string(windingIndex) + " has no turns — cannot refer the "
+            "magnetizing current to it.");
+    }
+    return primaryPeak * numberTurnsPrimary / numberTurnsWinding;
+}
+
 double calculate_temperature_from_core_thermal_resistance(json coreJson, double totalLosses) {
     OpenMagnetics::Core core(coreJson);
     
@@ -1073,6 +1137,40 @@ void register_core_bindings(py::module& m) {
         py::arg("magnetic_json"), py::arg("operating_point_json"),
         py::arg("temperature"));
 
+    m.def("calculate_peak_winding_current",
+        &calculate_peak_winding_current,
+        R"pbdoc(
+        Peak magnetizing (flux-driving) current at an operating point.
+
+        Returns the peak of the magnetizing current — the quantity that
+        actually drives core flux and therefore saturation — for the
+        as-designed magnetic at the supplied operating point. This is the
+        consistent partner to ``calculate_saturation_current_at_operating_point``:
+        both use the same operating-point magnetizing inductance, so the
+        caller can compare I_peak against I_sat on the same footing.
+
+        The magnetizing current is computed by MKF from the primary voltage
+        waveform (``I_mag = (1/L) ∫ v dt``) with the operating DC bias folded
+        in, NOT read back from the input current. For a transformer this is
+        the genuine flux-driving current, which differs from the primary
+        winding current (the latter includes reflected load current that
+        produces no net flux).
+
+        Args:
+            magnetic_json: JSON Magnetic object (core + coil).
+            operating_point_json: JSON OperatingPoint object with at least the
+                primary winding voltage excitation.
+            winding_index: Winding the result is referred to (default 0,
+                primary). For other windings the primary-referred peak is
+                scaled by the turns ratio N_0 / N_i — saturation is a single
+                core-flux property, so this is largely a unit choice.
+
+        Returns:
+            Peak magnetizing current in Amperes.
+        )pbdoc",
+        py::arg("magnetic_json"), py::arg("operating_point_json"),
+        py::arg("winding_index") = 0);
+
     m.def("calculate_saturation_current", &calculate_saturation_current,
         R"pbdoc(
         Calculate saturation current for a complete magnetic.

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/src/core.h

@@ -37,6 +37,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);
+double calculate_peak_winding_current(json magneticJson, json operatingPointJson, int windingIndex);
 double calculate_temperature_from_core_thermal_resistance(json coreJson, double totalLosses);
 
 // Gap and reluctance

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/src/losses.cpp

@@ -25,10 +25,6 @@ json calculate_core_losses(json coreData, json coilData, json inputsData, json m
     if (models.find("coreLosses") != models.end()) {
         OpenMagnetics::from_json(models["coreLosses"], coreLossesModelName);
     }
-    auto coreTemperatureModelName = OpenMagnetics::defaults.coreTemperatureModelDefault;
-    if (models.find("coreTemperature") != models.end()) {
-        OpenMagnetics::from_json(models["coreTemperature"], coreTemperatureModelName);
-    }
 
     OpenMagnetics::Magnetic magnetic;
     magnetic.set_core(core);
@@ -36,7 +32,6 @@ json calculate_core_losses(json coreData, json coilData, json inputsData, json m
 
     OpenMagnetics::MagneticSimulator magneticSimulator;
     magneticSimulator.set_core_losses_model_name(coreLossesModelName);
-    magneticSimulator.set_core_temperature_model_name(coreTemperatureModelName);
     magneticSimulator.set_reluctance_model_name(reluctanceModelName);
     auto coreLossesOutput = magneticSimulator.calculate_core_losses(operatingPoint, magnetic);
     json result;
@@ -66,15 +61,6 @@ json get_core_losses_model_information(json material) {
     return info;
 }
 
-json get_core_temperature_model_information() {
-    json info;
-    info["information"] = OpenMagnetics::CoreTemperatureModel::get_models_information();
-    info["errors"] = OpenMagnetics::CoreTemperatureModel::get_models_errors();
-    info["internal_links"] = OpenMagnetics::CoreTemperatureModel::get_models_internal_links();
-    info["external_links"] = OpenMagnetics::CoreTemperatureModel::get_models_external_links();
-    return info;
-}
-
 json calculate_steinmetz_coefficients(json dataJson, json rangesJson) {
     try {
         std::vector<std::pair<double, double>> ranges;
@@ -383,7 +369,6 @@ void register_losses_bindings(py::module& m) {
             models_data: JSON dict specifying models to use:
                 - "coreLosses": "STEINMETZ", "IGSE", "MSE", "BARG", "ROSHEN", "PROPRIETARY"
                 - "reluctance": "ZHANG", "MUEHLETHALER", "PARTRIDGE", "STENGLEIN"
-                - "coreTemperature": Model for temperature estimation
         
         Returns:
             JSON object containing:
@@ -423,14 +408,6 @@ void register_losses_bindings(py::module& m) {
         )pbdoc",
         py::arg("material"));
     
-    m.def("get_core_temperature_model_information", &get_core_temperature_model_information,
-        R"pbdoc(
-        Get documentation for available core temperature models.
-        
-        Returns:
-            JSON object with model information, errors, and reference links.
-        )pbdoc");
-    
     m.def("calculate_steinmetz_coefficients", &calculate_steinmetz_coefficients,
         R"pbdoc(
         Fit Steinmetz equation coefficients from measured loss data.

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/src/losses.h

@@ -7,7 +7,6 @@ namespace PyMKF {
 // Core losses
 json calculate_core_losses(json coreData, json coilData, json inputsData, json modelsData);
 json get_core_losses_model_information(json material);
-json get_core_temperature_model_information();
 json calculate_steinmetz_coefficients(json dataJson, json rangesJson);
 json calculate_steinmetz_coefficients_with_error(json dataJson, json rangesJson);
 

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/src/simulation.cpp

@@ -15,14 +15,9 @@ json simulate(json inputsJson, json magneticJson, json modelsData) {
         if (!modelsData.is_null() && modelsData.find("coreLosses") != modelsData.end()) {
             OpenMagnetics::from_json(modelsData["coreLosses"], coreLossesModelName);
         }
-        auto coreTemperatureModelName = OpenMagnetics::defaults.coreTemperatureModelDefault;
-        if (!modelsData.is_null() && modelsData.find("coreTemperature") != modelsData.end()) {
-            OpenMagnetics::from_json(modelsData["coreTemperature"], coreTemperatureModelName);
-        }
-        
+
         OpenMagnetics::MagneticSimulator magneticSimulator;
         magneticSimulator.set_core_losses_model_name(coreLossesModelName);
-        magneticSimulator.set_core_temperature_model_name(coreTemperatureModelName);
         magneticSimulator.set_reluctance_model_name(reluctanceModelName);
         auto mas = magneticSimulator.simulate(inputs, magnetic);
 

{pyopenmagnetics-1.4.6 → pyopenmagnetics-1.5.1}/tests/test_core.py

@@ -181,6 +181,90 @@ class TestCoreCalculations:
             assert isinstance(gapping, list)
 
 
+class TestPeakWindingCurrent:
+    """
+    Tests for calculate_peak_winding_current (ABT #16).
+
+    Verifies the binding that exposes the MKF-computed peak magnetizing
+    (flux-driving) current at an operating point, so Heaviside no longer
+    needs analytical I_peak fallbacks.
+    """
+
+    def _advise_magnetic(self, inputs):
+        proc = PyOpenMagnetics.process_inputs(inputs)
+        res = PyOpenMagnetics.calculate_advised_magnetics(proc, 1, "available cores")
+        data = json.loads(res) if isinstance(res, str) else res
+        data = data["data"] if isinstance(data, dict) and "data" in data else data
+        assert len(data) > 0, "adviser returned no magnetic"
+        mas = data[0].get("mas", data[0])
+        return mas["magnetic"], mas["inputs"]["operatingPoints"][0]
+
+    def test_inductor_peak_includes_dc_bias(self):
+        """
+        Peak magnetizing current must fold in the operating DC bias, not
+        return only the AC ripple amplitude. Input current here is a 5 A DC
+        bias with a 4 A peak-to-peak ripple.
+        """
+        op = {
+            "name": "Nominal",
+            "conditions": {"ambientTemperature": 25},
+            "excitationsPerWinding": [{
+                "frequency": 100000,
+                "current": {"waveform": {"data": [3, 7, 3],
+                                         "time": [0, 0.0000025, 0.00001]}},
+                "voltage": {"waveform": {"data": [-10, 30, 30, -10, -10],
+                                         "time": [0, 0, 0.0000025, 0.0000025, 0.00001]}},
+            }],
+        }
+        inputs = {
+            "designRequirements": {"magnetizingInductance": {"nominal": 100e-6},
+                                   "turnsRatios": []},
+            "operatingPoints": [op],
+        }
+        magnetic, op_used = self._advise_magnetic(inputs)
+
+        ipeak = PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used, 0)
+        # Default winding_index argument must match explicit 0.
+        assert ipeak == PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used)
+        assert ipeak > 0
+        # Must include the ~5 A DC bias, so well above the bare ripple amplitude.
+        assert ipeak > 4.0
+
+        # Consistent footing with I_sat at the same operating point.
+        isat = PyOpenMagnetics.calculate_saturation_current_at_operating_point(
+            magnetic, op_used, 25.0)
+        assert isat > ipeak  # an advised design should not be saturating
+
+    def test_transformer_winding_index_scales_by_turns_ratio(self):
+        """
+        For a transformer the per-winding magnetizing peak is the primary
+        value scaled by the turns ratio N_0 / N_i.
+        """
+        op = {
+            "name": "Nominal",
+            "conditions": {"ambientTemperature": 25},
+            "excitationsPerWinding": [{
+                "frequency": 100000,
+                "current": {"waveform": {"data": [-5, 5, -5],
+                                         "time": [0, 0.0000025, 0.00001]}},
+                "voltage": {"waveform": {"data": [-10, 30, 30, -10, -10],
+                                         "time": [0, 0, 0.0000025, 0.0000025, 0.00001]}},
+            }],
+        }
+        inputs = {
+            "designRequirements": {"magnetizingInductance": {"nominal": 100e-6},
+                                   "turnsRatios": [{"nominal": 2.0}]},
+            "operatingPoints": [op],
+        }
+        magnetic, op_used = self._advise_magnetic(inputs)
+        turns = [w["numberTurns"]
+                 for w in magnetic["coil"]["functionalDescription"]]
+
+        p0 = PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used, 0)
+        p1 = PyOpenMagnetics.calculate_peak_winding_current(magnetic, op_used, 1)
+        assert p1 == pytest.approx(p0 * turns[0] / turns[1], rel=1e-9)
+
+
 class TestCoreProcessedDescription:
     """Test suite for processed core descriptions."""