PyOpenMagnetics 1.2.0__tar.gz → 1.2.1__tar.gz

{pyopenmagnetics-1.2.0 → pyopenmagnetics-1.2.1}/PKG-INFO

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

{pyopenmagnetics-1.2.0 → pyopenmagnetics-1.2.1}/PyOpenMagnetics.pyi

@@ -685,11 +685,60 @@ def get_default_models() -> JsonDict:
     """Get default model selections."""
     ...
 
-# =============================================================================
-# CONVERTER TOPOLOGY PROCESSORS
-# =============================================================================
-
-def process_flyback(flyback: JsonDict) -> Inputs:
+# =============================================================================
+# CONVERTER TOPOLOGY PROCESSORS
+# =============================================================================
+
+def process_converter(topology: str, converter: JsonDict, use_ngspice: bool = True) -> JsonDict:
+    """Process a converter topology specification to Inputs.
+    
+    Generic endpoint that dispatches to the appropriate topology processor.
+    
+    Args:
+        topology: Topology name ("flyback", "buck", "boost", "single_switch_forward",
+                 "two_switch_forward", "active_clamp_forward", "push_pull", "llc",
+                 "cllc", "dab", "phase_shifted_full_bridge", "phase_shifted_half_bridge",
+                 "isolated_buck", "isolated_buck_boost", "current_transformer")
+        converter: JSON object with converter specification per MAS schema
+        use_ngspice: If True, uses ngspice simulation for waveform extraction
+    
+    Returns:
+        JSON object with "designRequirements" and "operatingPoints"
+        On error, returns {"error": "..."}
+    """
+    ...
+
+def design_magnetics_from_converter(
+    topology: str,
+    converter: JsonDict,
+    max_results: int = 1,
+    core_mode: str = "AVAILABLE_CORES",
+    use_ngspice: bool = True,
+    weights: Optional[Dict[str, float]] = None
+) -> JsonDict:
+    """Design magnetic components from a converter specification.
+    
+    High-level endpoint that combines converter processing with magnetic adviser
+    to go from converter specification directly to ranked magnetic designs.
+    
+    Args:
+        topology: Topology name (see process_converter for list)
+        converter: JSON object with converter specification per MAS schema
+        max_results: Maximum number of magnetic designs to return
+        core_mode: Core selection mode - "AVAILABLE_CORES" or "STANDARD_CORES"
+        use_ngspice: If True, uses ngspice simulation for waveform extraction
+        weights: Optional filter weights (e.g., {"COST": 1.0, "LOSSES": 2.0})
+    
+    Returns:
+        JSON object with "data" array containing ranked results.
+        Each result has:
+        - "mas": Mas object with magnetic design
+        - "scoring": Overall float score
+        - "scoringPerFilter": Object with individual filter scores
+    """
+    ...
+
+def process_flyback(flyback: JsonDict) -> Inputs:
     """Process Flyback converter specification to Inputs."""
     ...
 

{pyopenmagnetics-1.2.0 → pyopenmagnetics-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "PyOpenMagnetics"
-version = "1.2.0"
+version = "1.2.1"
 requires-python = ">=3.8"
 authors = [
   { name="Alfonso Martinez", email="Alfonso_VII@hotmail.com" },
@@ -48,15 +48,15 @@ manylinux-pypy_aarch64-image = "manylinux_2_28"
 environment = { GIT_LFS_SKIP_SMUDGE=1 }
 build-verbosity = 1
 
-[tool.cibuildwheel.linux]
-before-all = [
-  "rm -rf /project/build /root/.cmake",
-  "dnf -y module reset nodejs",
-  "dnf -y module enable nodejs:20",
-  "dnf -y install nodejs npm",
-  "npm --version",
-  "npm install -g quicktype@23.0.170"
-]
+[tool.cibuildwheel.linux]
+before-all = [
+  "rm -rf /project/build /root/.cmake",
+  "dnf -y module reset nodejs",
+  "dnf -y module enable nodejs:20",
+  "dnf -y install nodejs npm",
+  "npm --version",
+  "npm install -g quicktype@23.0.170"
+]
 environment = { GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="3" }
 
 [tool.cibuildwheel.macos]

{pyopenmagnetics-1.2.0 → pyopenmagnetics-1.2.1}/src/common.h

@@ -33,6 +33,7 @@
 #include "processors/Inputs.h"
 #include "processors/MagneticSimulator.h"
 #include "processors/CircuitSimulatorInterface.h"
+#include "processors/NgspiceRunner.h"
 #include "support/Painter.h"
 #include "support/Utils.h"
 

pyopenmagnetics-1.2.1/src/converter.cpp

@@ -0,0 +1,583 @@
+#include "converter.h"
+
+// Include all converter model headers
+#include "converter_models/Flyback.h"
+#include "converter_models/Buck.h"
+#include "converter_models/Boost.h"
+#include "converter_models/SingleSwitchForward.h"
+#include "converter_models/TwoSwitchForward.h"
+#include "converter_models/ActiveClampForward.h"
+#include "converter_models/PushPull.h"
+#include "converter_models/Llc.h"
+#include "converter_models/Cllc.h"
+#include "converter_models/Dab.h"
+#include "converter_models/PhaseShiftedFullBridge.h"
+#include "converter_models/PhaseShiftedHalfBridge.h"
+#include "converter_models/IsolatedBuck.h"
+#include "converter_models/IsolatedBuckBoost.h"
+#include "converter_models/CurrentTransformer.h"
+#include "converter_models/PowerFactorCorrection.h"
+
+namespace PyMKF {
+
+OpenMagnetics::Inputs process_flyback_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedFlyback converter(converterJson);
+    converter._assertErrors = true;
+    
+    if (useNgspice) {
+        // Get design parameters directly from AdvancedFlyback
+        std::vector<double> turnsRatios = converter.get_desired_turns_ratios();
+        double inductance = converter.get_desired_inductance();
+        auto operatingPoints = converter.simulate_and_extract_operating_points(turnsRatios, inductance);
+        
+        // Build DesignRequirements manually like AdvancedFlyback::process() does
+        OpenMagnetics::DesignRequirements designReqs;
+        designReqs.get_mutable_turns_ratios().clear();
+        for (auto turnsRatio : turnsRatios) {
+            OpenMagnetics::DimensionWithTolerance turnsRatioWithTolerance;
+            turnsRatioWithTolerance.set_nominal(turnsRatio);
+            designReqs.get_mutable_turns_ratios().push_back(turnsRatioWithTolerance);
+        }
+        OpenMagnetics::DimensionWithTolerance inductanceWithTolerance;
+        inductanceWithTolerance.set_nominal(inductance);
+        designReqs.set_magnetizing_inductance(inductanceWithTolerance);
+        designReqs.set_topology(MAS::Topologies::FLYBACK_CONVERTER);
+        
+        OpenMagnetics::Inputs result;
+        result.set_design_requirements(designReqs);
+        result.set_operating_points(operatingPoints);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::FLYBACK_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_buck_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedBuck 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(MAS::Topologies::BUCK_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::BUCK_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_boost_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedBoost 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(MAS::Topologies::BOOST_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::BOOST_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_single_switch_forward_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedSingleSwitchForward 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(MAS::Topologies::SINGLE_SWITCH_FORWARD_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::SINGLE_SWITCH_FORWARD_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_two_switch_forward_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedTwoSwitchForward 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(MAS::Topologies::TWO_SWITCH_FORWARD_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::TWO_SWITCH_FORWARD_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_active_clamp_forward_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedActiveClampForward 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(MAS::Topologies::ACTIVE_CLAMP_FORWARD_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::ACTIVE_CLAMP_FORWARD_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_push_pull_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedPushPull 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(MAS::Topologies::PUSH_PULL_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::PUSH_PULL_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_llc_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedLlc 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(MAS::Topologies::LLC_RESONANT_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::LLC_RESONANT_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_cllc_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedCllcConverter 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);
+        return result;
+    } else {
+        return converter.process();
+    }
+}
+
+OpenMagnetics::Inputs process_dab_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedDab 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);
+        return result;
+    } else {
+        return converter.process();
+    }
+}
+
+OpenMagnetics::Inputs process_psfb_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedPsfb 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);
+        return result;
+    } else {
+        return converter.process();
+    }
+}
+
+OpenMagnetics::Inputs process_pshb_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedPshb 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);
+        return result;
+    } else {
+        return converter.process();
+    }
+}
+
+OpenMagnetics::Inputs process_isolated_buck_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedIsolatedBuck 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(MAS::Topologies::ISOLATED_BUCK_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::ISOLATED_BUCK_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_isolated_buck_boost_internal(const json& converterJson, bool useNgspice) {
+    OpenMagnetics::AdvancedIsolatedBuckBoost 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(MAS::Topologies::ISOLATED_BUCK_BOOST_CONVERTER);
+        return result;
+    } else {
+        OpenMagnetics::Inputs result = converter.process();
+        result.get_mutable_design_requirements().set_topology(MAS::Topologies::ISOLATED_BUCK_BOOST_CONVERTER);
+        return result;
+    }
+}
+
+OpenMagnetics::Inputs process_current_transformer_internal(const json& converterJson) {
+    OpenMagnetics::CurrentTransformer converter(converterJson);
+    converter._assertErrors = true;
+    
+    double turnsRatio = converterJson.contains("turnsRatio") ? converterJson["turnsRatio"].get<double>() : 100.0;
+    double secondaryResistance = converterJson.contains("secondaryResistance") ? converterJson["secondaryResistance"].get<double>() : 0.0;
+    OpenMagnetics::Inputs result = converter.process(turnsRatio, secondaryResistance);
+    result.get_mutable_design_requirements().set_topology(MAS::Topologies::CURRENT_TRANSFORMER);
+    return result;
+}
+
+OpenMagnetics::Inputs process_pfc_internal(const json& converterJson) {
+    OpenMagnetics::PowerFactorCorrection converter(converterJson);
+    converter._assertErrors = true;
+    return converter.process();
+}
+
+OpenMagnetics::Inputs dispatch_converter(const std::string& topologyName, const json& converterJson, bool useNgspice) {
+    if (topologyName == "flyback" || topologyName == "advanced_flyback") {
+        return process_flyback_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "buck" || topologyName == "advanced_buck") {
+        return process_buck_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "boost" || topologyName == "advanced_boost") {
+        return process_boost_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "single_switch_forward") {
+        return process_single_switch_forward_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "two_switch_forward") {
+        return process_two_switch_forward_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "active_clamp_forward") {
+        return process_active_clamp_forward_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "push_pull") {
+        return process_push_pull_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "llc" || topologyName == "advanced_llc") {
+        return process_llc_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "cllc" || topologyName == "advanced_cllc") {
+        return process_cllc_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "dab" || topologyName == "advanced_dab") {
+        return process_dab_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "phase_shifted_full_bridge" || topologyName == "psfb") {
+        return process_psfb_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "phase_shifted_half_bridge" || topologyName == "pshb") {
+        return process_pshb_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "isolated_buck") {
+        return process_isolated_buck_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "isolated_buck_boost") {
+        return process_isolated_buck_boost_internal(converterJson, useNgspice);
+    }
+    else if (topologyName == "current_transformer") {
+        return process_current_transformer_internal(converterJson);
+    }
+    else if (topologyName == "power_factor_correction" || topologyName == "pfc") {
+        return process_pfc_internal(converterJson);
+    }
+    else {
+        throw std::invalid_argument("Unknown topology: " + topologyName);
+    }
+}
+
+json process_converter_internal(const std::string& topologyName, const json& converterJson, bool useNgspice) {
+    try {
+        OpenMagnetics::Inputs inputs = dispatch_converter(topologyName, converterJson, useNgspice);
+        json result;
+        to_json(result, inputs);
+        return result;
+    }
+    catch (const std::exception& e) {
+        json error;
+        error["error"] = "Exception: " + std::string(e.what());
+        return error;
+    }
+}
+
+json process_converter(const std::string& topologyName, json converterJson, bool useNgspice) {
+    return process_converter_internal(topologyName, converterJson, useNgspice);
+}
+
+json design_magnetics_from_converter(
+    const std::string& topologyName, 
+    json converterJson, 
+    int maxResults, 
+    json coreModeJson, 
+    bool useNgspice, 
+    json weightsJson) {
+    
+    try {
+        json inputsJson = process_converter_internal(topologyName, converterJson, useNgspice);
+        
+        if (inputsJson.contains("error")) {
+            return inputsJson;
+        }
+        
+        OpenMagnetics::Inputs inputs(inputsJson);
+        
+        OpenMagnetics::CoreAdviser::CoreAdviserModes coreMode;
+        from_json(coreModeJson, coreMode);
+        
+        std::map<OpenMagnetics::MagneticFilters, double> weights;
+        if (!weightsJson.is_null()) {
+            for (auto& [key, value] : weightsJson.items()) {
+                OpenMagnetics::MagneticFilters filter;
+                OpenMagnetics::from_json(key, filter);
+                weights[filter] = value;
+            }
+        }
+        
+        OpenMagnetics::MagneticAdviser magneticAdviser;
+        magneticAdviser.set_core_mode(coreMode);
+        
+        std::vector<std::pair<OpenMagnetics::Mas, double>> masMagnetics;
+        if (weights.empty()) {
+            masMagnetics = magneticAdviser.get_advised_magnetic(inputs, maxResults);
+        } else {
+            masMagnetics = magneticAdviser.get_advised_magnetic(inputs, weights, maxResults);
+        }
+        
+        auto scoringsPerFilter = magneticAdviser.get_scorings();
+        
+        json results = json();
+        results["data"] = json::array();
+        for (size_t i = 0; i < masMagnetics.size(); ++i) {
+            auto& masMagnetic = masMagnetics[i].first;
+            double scoring = masMagnetics[i].second;
+            std::string name = masMagnetic.get_magnetic().get_manufacturer_info().value().get_reference().value();
+            json result;
+            json masJson;
+            to_json(masJson, masMagnetic);
+            result["mas"] = masJson;
+            result["scoring"] = scoring;
+            if (scoringsPerFilter.count(name)) {
+                json filterScorings;
+                for (auto& filterPair : scoringsPerFilter[name]) {
+                    auto filter = filterPair.first;
+                    double filterScore = filterPair.second;
+                    filterScorings[std::string(magic_enum::enum_name(filter))] = filterScore;
+                }
+                result["scoringPerFilter"] = filterScorings;
+            }
+            results["data"].push_back(result);
+        }
+        
+        sort(results["data"].begin(), results["data"].end(), [](json& b1, json& b2) {
+            return b1["scoring"] > b2["scoring"];
+        });
+        
+        OpenMagnetics::settings.reset();
+        
+        return results;
+    }
+    catch (const std::exception& e) {
+        json error;
+        error["error"] = "Exception: " + std::string(e.what());
+        return error;
+    }
+}
+
+json process_flyback(json flybackJson) {
+    return process_converter("flyback", flybackJson, true);
+}
+
+json process_buck(json buckJson) {
+    return process_converter("buck", buckJson, true);
+}
+
+json process_boost(json boostJson) {
+    return process_converter("boost", boostJson, true);
+}
+
+json process_single_switch_forward(json forwardJson) {
+    return process_converter("single_switch_forward", forwardJson, true);
+}
+
+json process_two_switch_forward(json forwardJson) {
+    return process_converter("two_switch_forward", forwardJson, true);
+}
+
+json process_active_clamp_forward(json forwardJson) {
+    return process_converter("active_clamp_forward", forwardJson, true);
+}
+
+json process_push_pull(json pushPullJson) {
+    return process_converter("push_pull", pushPullJson, true);
+}
+
+json process_isolated_buck(json isolatedBuckJson) {
+    return process_converter("isolated_buck", isolatedBuckJson, true);
+}
+
+json process_isolated_buck_boost(json isolatedBuckBoostJson) {
+    return process_converter("isolated_buck_boost", isolatedBuckBoostJson, true);
+}
+
+json process_current_transformer(json ctJson, double turnsRatio, double secondaryResistance) {
+    ctJson["turnsRatio"] = turnsRatio;
+    ctJson["secondaryResistance"] = secondaryResistance;
+    return process_converter("current_transformer", ctJson, true);
+}
+
+void register_converter_bindings(py::module& m) {
+    m.def("process_converter", &process_converter,
+        "Process a converter topology specification to Inputs.",
+        py::arg("topology_name"), py::arg("converter_json"), py::arg("use_ngspice") = true);
+    
+    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("max_results") = 1, py::arg("core_mode_json") = "AVAILABLE_CORES",
+        py::arg("use_ngspice") = true, py::arg("weights_json") = nullptr);
+    
+    m.def("process_flyback", &process_flyback, "Process Flyback converter.", py::arg("flyback"));
+    m.def("process_buck", &process_buck, "Process Buck converter.", py::arg("buck"));
+    m.def("process_boost", &process_boost, "Process Boost converter.", py::arg("boost"));
+    m.def("process_single_switch_forward", &process_single_switch_forward, "Process Single-Switch Forward.", py::arg("forward"));
+    m.def("process_two_switch_forward", &process_two_switch_forward, "Process Two-Switch Forward.", py::arg("forward"));
+    m.def("process_active_clamp_forward", &process_active_clamp_forward, "Process Active Clamp Forward.", py::arg("forward"));
+    m.def("process_push_pull", &process_push_pull, "Process Push-Pull converter.", py::arg("push_pull"));
+    m.def("process_isolated_buck", &process_isolated_buck, "Process Isolated Buck.", py::arg("isolated_buck"));
+    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);
+}
+
+} // namespace PyMKF

pyopenmagnetics-1.2.1/src/converter.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "common.h"
+
+namespace PyMKF {
+
+// Main generic converter processor
+json process_converter(const std::string& topologyName, json converterJson, bool useNgspice = true);
+
+// 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);
+
+// Per-topology thin wrappers (from .pyi stubs)
+json process_flyback(json flybackJson);
+json process_buck(json buckJson);
+json process_boost(json boostJson);
+json process_single_switch_forward(json forwardJson);
+json process_two_switch_forward(json forwardJson);
+json process_active_clamp_forward(json forwardJson);
+json process_push_pull(json pushPullJson);
+json process_isolated_buck(json isolatedBuckJson);
+json process_isolated_buck_boost(json isolatedBuckBoostJson);
+json process_current_transformer(json ctJson, double turnsRatio, double secondaryResistance = 0.0);
+
+void register_converter_bindings(py::module& m);
+
+} // namespace PyMKF

{pyopenmagnetics-1.2.0 → pyopenmagnetics-1.2.1}/src/module.cpp

@@ -5,6 +5,7 @@
 #include "bobbin.h"
 #include "winding.h"
 #include "advisers.h"
+#include "converter.h"
 #include "losses.h"
 #include "simulation.h"
 #include "plotting.h"
@@ -22,6 +23,7 @@ PYBIND11_MODULE(PyOpenMagnetics, m) {
     PyMKF::register_bobbin_bindings(m);
     PyMKF::register_winding_bindings(m);
     PyMKF::register_adviser_bindings(m);
+    PyMKF::register_converter_bindings(m);
     PyMKF::register_losses_bindings(m);
     PyMKF::register_simulation_bindings(m);
     PyMKF::register_plotting_bindings(m);

pyopenmagnetics-1.2.1/tests/test_converter_endpoints.py

@@ -0,0 +1,235 @@
+"""Tests for converter topology endpoints."""
+import json
+import PyOpenMagnetics as PyMKF
+
+
+def test_process_flyback():
+    """Test Flyback converter processing."""
+    flyback = {
+        "inputVoltage": {"minimum": 150, "maximum": 150},
+        "desiredInductance": 400e-6,
+        "desiredTurnsRatios": [6.14],
+        "desiredDutyCycle": [[0.45, 0.45]],
+        "maximumDutyCycle": 0.5,
+        "efficiency": 0.9,
+        "diodeVoltageDrop": 0.7,
+        "operatingPoints": [{
+            "outputVoltages": [20.0],
+            "outputCurrents": [1.5],
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+    
+    # Test with ngspice (default)
+    result = PyMKF.process_converter("flyback", flyback, use_ngspice=True)
+    assert "error" not in result, f"Error: {result.get('error')}"
+    assert "designRequirements" in result
+    assert "operatingPoints" in result
+    print("✓ Flyback converter processed successfully")
+
+
+def test_process_buck():
+    """Test Buck converter processing."""
+    buck = {
+        "inputVoltage": {"minimum": 12, "maximum": 12},
+        "desiredInductance": 10e-6,
+        "diodeVoltageDrop": 0.7,
+        "operatingPoints": [{
+            "outputVoltage": 5.0,
+            "outputCurrent": 2.0,
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+
+    result = PyMKF.process_converter("buck", buck, use_ngspice=False)  # Use analytical for speed
+    assert "error" not in result, f"Error: {result.get('error')}"
+    assert "designRequirements" in result
+    assert "operatingPoints" in result
+    print("✓ Buck converter processed successfully")
+
+
+def test_process_boost():
+    """Test Boost converter processing."""
+    boost = {
+        "inputVoltage": {"minimum": 5, "maximum": 5},
+        "desiredInductance": 10e-6,
+        "diodeVoltageDrop": 0.7,
+        "operatingPoints": [{
+            "outputVoltage": 12.0,
+            "outputCurrent": 1.0,
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+
+    result = PyMKF.process_converter("boost", boost, use_ngspice=False)
+    assert "error" not in result, f"Error: {result.get('error')}"
+    assert "designRequirements" in result
+    assert "operatingPoints" in result
+    print("✓ Boost converter processed successfully")
+
+
+def test_design_magnetics_from_flyback():
+    """Test full magnetic design from Flyback converter."""
+    flyback = {
+        "inputVoltage": {"minimum": 150, "maximum": 150},
+        "desiredInductance": 400e-6,
+        "desiredTurnsRatios": [6.14],
+        "desiredDutyCycle": [[0.45, 0.45]],
+        "maximumDutyCycle": 0.5,
+        "efficiency": 0.9,
+        "diodeVoltageDrop": 0.7,
+        "operatingPoints": [{
+            "outputVoltages": [20.0],
+            "outputCurrents": [1.5],
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+    
+    # Design with analytical waveforms (faster)
+    # Note: This test is skipped in CI as magnetic adviser can take a long time
+    print("✓ Magnetic design test skipped (too slow for unit test)")
+    print("  Use design_magnetics_from_converter() for full magnetic design")
+
+
+def test_per_topology_wrappers():
+    """Test per-topology wrapper functions."""
+
+    # Test process_flyback wrapper
+    flyback = {
+        "inputVoltage": {"minimum": 100, "maximum": 100},
+        "desiredInductance": 1e-3,
+        "desiredTurnsRatios": [10.0],
+        "desiredDutyCycle": [[0.45]],
+        "maximumDutyCycle": 0.5,
+        "diodeVoltageDrop": 0.7,
+        "efficiency": 0.9,
+        "operatingPoints": [{
+            "outputVoltages": [10.0],
+            "outputCurrents": [1.0],
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+
+    result = PyMKF.process_flyback(flyback)
+    assert "error" not in result
+    print("✓ process_flyback wrapper works")
+
+    # Test process_buck wrapper
+    buck = {
+        "inputVoltage": {"minimum": 12, "maximum": 12},
+        "desiredInductance": 10e-6,
+        "diodeVoltageDrop": 0.7,
+        "currentRippleRatio": 0.3,
+        "operatingPoints": [{
+            "outputVoltage": 5.0,
+            "outputCurrent": 2.0,
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+
+    result = PyMKF.process_buck(buck)
+    assert "error" not in result, f"Error: {result.get('error')}"
+    print("✓ process_buck wrapper works")
+
+
+def test_invalid_topology():
+    """Test error handling for invalid topology."""
+    converter = {"some": "data"}
+    
+    result = PyMKF.process_converter("invalid_topology", converter)
+    assert "error" in result
+    assert "Unknown topology" in result["error"]
+    print("✓ Invalid topology error handling works")
+
+
+def test_llc_converter():
+    """Test LLC resonant converter."""
+    llc = {
+        "inputVoltage": {"minimum": 400, "maximum": 400},
+        "desiredInductance": 100e-6,
+        "desiredTurnsRatios": [1.0],
+        "minSwitchingFrequency": 80000,
+        "maxSwitchingFrequency": 120000,
+        "operatingPoints": [{
+            "outputVoltages": [48.0],
+            "outputCurrents": [5.0],
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+
+    result = PyMKF.process_converter("llc", llc, use_ngspice=False)
+    assert "error" not in result, f"Error: {result.get('error')}"
+    assert "designRequirements" in result
+    print("✓ LLC converter processed successfully")
+
+
+def test_forward_converters():
+    """Test Forward converter variants."""
+    # Single switch forward: turns ratios must have one more position than outputs for demagnetization winding
+    single_switch_forward = {
+        "inputVoltage": {"minimum": 48, "maximum": 48},
+        "desiredInductance": 1e-3,
+        "desiredTurnsRatios": [1.0, 2.0],  # [demagnetization, output]
+        "diodeVoltageDrop": 0.7,
+        "currentRippleRatio": 0.2,
+        "operatingPoints": [{
+            "outputVoltages": [12.0],
+            "outputCurrents": [5.0],
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+
+    # Single switch forward
+    result = PyMKF.process_converter("single_switch_forward", single_switch_forward, use_ngspice=False)
+    assert "error" not in result, f"Error: {result.get('error')}"
+    print("✓ Single-switch forward processed successfully")
+
+    # Two switch forward and Active clamp forward: turns ratios must have same positions as outputs
+    other_forward = {
+        "inputVoltage": {"minimum": 48, "maximum": 48},
+        "desiredInductance": 1e-3,
+        "desiredTurnsRatios": [2.0],  # Same as number of outputs
+        "diodeVoltageDrop": 0.7,
+        "currentRippleRatio": 0.2,
+        "operatingPoints": [{
+            "outputVoltages": [12.0],
+            "outputCurrents": [5.0],
+            "switchingFrequency": 100000,
+            "ambientTemperature": 25
+        }]
+    }
+
+    # Two switch forward
+    result = PyMKF.process_converter("two_switch_forward", other_forward, use_ngspice=False)
+    assert "error" not in result, f"Error: {result.get('error')}"
+    print("✓ Two-switch forward processed successfully")
+
+    # Active clamp forward
+    result = PyMKF.process_converter("active_clamp_forward", other_forward, use_ngspice=False)
+    assert "error" not in result, f"Error: {result.get('error')}"
+    print("✓ Active clamp forward processed successfully")
+
+
+if __name__ == "__main__":
+    print("Running converter topology tests...\n")
+    
+    test_process_flyback()
+    test_process_buck()
+    test_process_boost()
+    test_llc_converter()
+    test_forward_converters()
+    test_per_topology_wrappers()
+    test_invalid_topology()
+    
+    print("\n--- Full Design Flow Test ---")
+    test_design_magnetics_from_flyback()
+    
+    print("\n✓ All tests passed!")