PyOpenMagnetics 1.1.0__tar.gz → 1.1.2__tar.gz

{pyopenmagnetics-1.1.0 → pyopenmagnetics-1.1.2}/PKG-INFO

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

{pyopenmagnetics-1.1.0 → pyopenmagnetics-1.1.2}/pyproject.toml

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

{pyopenmagnetics-1.1.0 → pyopenmagnetics-1.1.2}/src/advisers.cpp

@@ -24,12 +24,31 @@ json calculate_advised_cores(json inputsJson, json weightsJson, int maximumNumbe
         coreAdviser.set_mode(coreMode);
         auto masMagnetics = coreAdviser.get_advised_core(inputs, weights, maximumNumberResults);
 
-        json results = json::array();
-        for (auto& masMagnetic : masMagnetics) {
-            json aux;
-            to_json(aux, masMagnetic.first);
-            results.push_back(aux);
+        auto scoringsPerFilter = coreAdviser.get_scorings();
+
+        json results = json();
+        results["data"] = json::array();
+        for (auto& [masMagnetic, scoring] : masMagnetics) {
+            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& [filter, filterScore] : scoringsPerFilter[name]) {
+                    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;
@@ -51,13 +70,31 @@ json calculate_advised_magnetics(json inputsJson, int maximumNumberResults, json
         magneticAdviser.set_core_mode(coreMode);
         auto masMagnetics = magneticAdviser.get_advised_magnetic(inputs, maximumNumberResults);
 
-        json results = json::array();
+        auto scoringsPerFilter = magneticAdviser.get_scorings();
+
+        json results = json();
+        results["data"] = json::array();
         for (auto& [masMagnetic, scoring] : masMagnetics) {
-            json aux;
-            to_json(aux, masMagnetic);
-            results.push_back(aux);
+            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& [filter, filterScore] : scoringsPerFilter[name]) {
+                    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"];
+        });
+
         return results;
     }
     catch (const std::exception &exc) {
@@ -83,7 +120,7 @@ json calculate_advised_magnetics_from_catalog(json inputsJson, json catalogJson,
         OpenMagnetics::MagneticAdviser magneticAdviser;
         auto masMagnetics = magneticAdviser.get_advised_magnetic(inputs, catalog, maximumNumberResults);
 
-        auto scorings = magneticAdviser.get_scorings();
+        auto scoringsPerFilter = magneticAdviser.get_scorings();
 
         json results = json();
         results["data"] = json::array();
@@ -94,6 +131,13 @@ json calculate_advised_magnetics_from_catalog(json inputsJson, json catalogJson,
             to_json(masJson, masMagnetic);
             result["mas"] = masJson;
             result["scoring"] = scoring;
+            if (scoringsPerFilter.count(name)) {
+                json filterScorings;
+                for (auto& [filter, filterScore] : scoringsPerFilter[name]) {
+                    filterScorings[std::string(magic_enum::enum_name(filter))] = filterScore;
+                }
+                result["scoringPerFilter"] = filterScorings;
+            }
             results["data"].push_back(result);
         }
 
@@ -129,7 +173,7 @@ json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson
         OpenMagnetics::MagneticAdviser magneticAdviser;
         auto masMagnetics = magneticAdviser.get_advised_magnetic(inputs, OpenMagnetics::magneticsCache.get(), filterFlow, maximumNumberResults);
 
-        auto scorings = magneticAdviser.get_scorings();
+        auto scoringsPerFilter = magneticAdviser.get_scorings();
 
         json results = json();
         results["data"] = json::array();
@@ -140,6 +184,13 @@ json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson
             to_json(masJson, masMagnetic);
             result["mas"] = masJson;
             result["scoring"] = scoring;
+            if (scoringsPerFilter.count(name)) {
+                json filterScorings;
+                for (auto& [filter, filterScore] : scoringsPerFilter[name]) {
+                    filterScorings[std::string(magic_enum::enum_name(filter))] = filterScore;
+                }
+                result["scoringPerFilter"] = filterScorings;
+            }
             results["data"].push_back(result);
         }
 
@@ -171,13 +222,19 @@ void register_adviser_bindings(py::module& m) {
             core_mode_json: Core selection mode - "AVAILABLE_CORES" or "STANDARD_CORES".
         
         Returns:
-            JSON array of recommended cores sorted by score (best first).
-            Each element contains core data with functional and processed descriptions.
+            JSON object with "data" array containing ranked results.
+            Each result has:
+            - "mas": Mas object with magnetic data
+            - "scoring": Overall float score
+            - "scoringPerFilter": Object with individual scores per filter
+              (e.g., {"COST": 0.8, "EFFICIENCY": 0.9, "DIMENSIONS": 0.7})
         
         Example:
             >>> inputs = PyMKF.process_inputs(raw_inputs)
             >>> weights = {"COST": 1, "EFFICIENCY": 1, "DIMENSIONS": 0.5}
-            >>> cores = PyMKF.calculate_advised_cores(inputs, weights, 10, "AVAILABLE_CORES")
+            >>> result = PyMKF.calculate_advised_cores(inputs, weights, 10, "AVAILABLE_CORES")
+            >>> for item in result["data"]:
+            ...     print(f"Score: {item['scoring']}, Per filter: {item['scoringPerFilter']}")
         )pbdoc",
         py::arg("inputs_json"), py::arg("weights_json"), 
         py::arg("max_results"), py::arg("core_mode_json"));
@@ -197,12 +254,18 @@ void register_adviser_bindings(py::module& m) {
             core_mode_json: Core selection mode - "AVAILABLE_CORES" or "STANDARD_CORES".
         
         Returns:
-            JSON array of complete Mas objects sorted by score (best first).
-            Each Mas contains: magnetic (core + coil), inputs, and optionally outputs.
+            JSON object with "data" array containing ranked results.
+            Each result has:
+            - "mas": Mas object with magnetic, inputs, and optionally outputs
+            - "scoring": Overall float score
+            - "scoringPerFilter": Object with individual scores per filter
+              (e.g., {"COST": 0.8, "LOSSES": 0.9, "DIMENSIONS": 0.7})
         
         Example:
             >>> inputs = PyMKF.process_inputs(raw_inputs)
-            >>> magnetics = PyMKF.calculate_advised_magnetics(inputs, 5, "AVAILABLE_CORES")
+            >>> result = PyMKF.calculate_advised_magnetics(inputs, 5, "AVAILABLE_CORES")
+            >>> for item in result["data"]:
+            ...     print(f"Score: {item['scoring']}, Per filter: {item['scoringPerFilter']}")
         )pbdoc",
         py::arg("inputs_json"), py::arg("max_results"), py::arg("core_mode_json"));
     
@@ -220,14 +283,17 @@ void register_adviser_bindings(py::module& m) {
         
         Returns:
             JSON object with "data" array containing ranked results.
-            Each result has "mas" (Mas object) and "scoring" (float score).
+            Each result has:
+            - "mas": Mas object with magnetic data
+            - "scoring": Overall float score
+            - "scoringPerFilter": Object with individual scores per filter
         
         Example:
             >>> inputs = PyMKF.process_inputs(raw_inputs)
             >>> catalog = [magnetic1, magnetic2, magnetic3]
             >>> result = PyMKF.calculate_advised_magnetics_from_catalog(inputs, catalog, 5)
             >>> for item in result["data"]:
-            ...     print(f"Score: {item['scoring']}")
+            ...     print(f"Score: {item['scoring']}, Per filter: {item['scoringPerFilter']}")
         )pbdoc",
         py::arg("inputs_json"), py::arg("catalog_json"), py::arg("max_results"));
     
@@ -247,6 +313,10 @@ void register_adviser_bindings(py::module& m) {
         Returns:
             JSON object with "data" array containing ranked results,
             or error string if cache is empty.
+            Each result has:
+            - "mas": Mas object with magnetic data
+            - "scoring": Overall float score
+            - "scoringPerFilter": Object with individual scores per filter
         
         Note:
             Cache must be populated before calling this function.

{pyopenmagnetics-1.1.0 → pyopenmagnetics-1.1.2}/src/common.h

@@ -25,8 +25,11 @@
 #include "physical_models/Resistivity.h"
 #include "physical_models/CoreTemperature.h"
 #include "physical_models/LeakageInductance.h"
+#include "physical_models/Inductance.h"
+#include "physical_models/StrayCapacitance.h"
 #include "physical_models/WindingOhmicLosses.h"
 #include "physical_models/WindingSkinEffectLosses.h"
+#include "physical_models/WindingLosses.h"
 #include "processors/Inputs.h"
 #include "processors/MagneticSimulator.h"
 #include "processors/CircuitSimulatorInterface.h"

{pyopenmagnetics-1.1.0 → pyopenmagnetics-1.1.2}/src/simulation.cpp

@@ -190,6 +190,126 @@ json extract_column_names(json fileJson) {
     }
 }
 
+json calculate_inductance_matrix(json magneticJson, double frequency, json modelsData) {
+    try {
+        OpenMagnetics::Magnetic magnetic(magneticJson);
+        
+        auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
+        if (!modelsData.is_null() && modelsData.find("reluctance") != modelsData.end()) {
+            OpenMagnetics::from_json(modelsData["reluctance"], reluctanceModelName);
+        }
+
+        OpenMagnetics::Inductance inductance(reluctanceModelName);
+        auto inductanceMatrix = inductance.calculate_inductance_matrix(magnetic, frequency);
+
+        json result;
+        to_json(result, inductanceMatrix);
+        return result;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
+json calculate_leakage_inductance(json magneticJson, double frequency, size_t sourceIndex) {
+    try {
+        OpenMagnetics::Magnetic magnetic(magneticJson);
+
+        auto leakageInductanceOutput = OpenMagnetics::LeakageInductance().calculate_leakage_inductance_all_windings(magnetic, frequency, sourceIndex);
+
+        json result;
+        to_json(result, leakageInductanceOutput);
+        return result;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
+json calculate_dc_resistance_per_winding(json coilJson, double temperature) {
+    try {
+        OpenMagnetics::Coil coil(coilJson, false);
+        
+        auto resistances = OpenMagnetics::WindingOhmicLosses::calculate_dc_resistance_per_winding(coil, temperature);
+
+        json result = resistances;
+        return result;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
+json calculate_resistance_matrix(json magneticJson, double temperature, double frequency) {
+    try {
+        OpenMagnetics::Magnetic magnetic(magneticJson);
+        
+        OpenMagnetics::WindingLosses windingLosses;
+        auto resistanceMatrix = windingLosses.calculate_resistance_matrix(magnetic, temperature, frequency);
+
+        json result;
+        to_json(result, resistanceMatrix);
+        return result;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
+json calculate_stray_capacitance(json coilJson, json operatingPointJson, json modelsData) {
+    try {
+        OpenMagnetics::Coil coil(coilJson, false);
+        OperatingPoint operatingPoint(operatingPointJson);
+        
+        auto strayCapacitanceModelName = OpenMagnetics::StrayCapacitanceModels::ALBACH;
+        if (!modelsData.is_null() && modelsData.find("strayCapacitance") != modelsData.end()) {
+            OpenMagnetics::from_json(modelsData["strayCapacitance"], strayCapacitanceModelName);
+        }
+
+        OpenMagnetics::StrayCapacitance strayCapacitance(strayCapacitanceModelName);
+        auto strayCapacitanceOutput = strayCapacitance.calculate_capacitance(coil);
+
+        json result;
+        to_json(result, strayCapacitanceOutput);
+        return result;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
+json calculate_maxwell_capacitance_matrix(json coilJson, json capacitanceAmongWindingsJson) {
+    try {
+        OpenMagnetics::Coil coil(coilJson, false);
+        auto capacitanceAmongWindings = capacitanceAmongWindingsJson.get<std::map<std::string, std::map<std::string, double>>>();
+
+        auto maxwellMatrix = OpenMagnetics::StrayCapacitance::calculate_maxwell_capacitance_matrix(coil, capacitanceAmongWindings);
+
+        json result = json::array();
+        for (const auto& matrix : maxwellMatrix) {
+            json matrixJson;
+            to_json(matrixJson, matrix);
+            result.push_back(matrixJson);
+        }
+        return result;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
 void register_simulation_bindings(py::module& m) {
     m.def("simulate", &simulate,
         R"pbdoc(
@@ -304,6 +424,102 @@ void register_simulation_bindings(py::module& m) {
         Returns:
             JSON array of column name strings.
         )pbdoc");
+    
+    m.def("calculate_inductance_matrix", &calculate_inductance_matrix,
+        R"pbdoc(
+        Calculate the complete inductance matrix for a magnetic component.
+        
+        Computes the inductance matrix at the specified frequency, including
+        self inductances (diagonal elements) and mutual inductances (off-diagonal).
+        
+        Args:
+            magnetic_json: JSON object containing magnetic component specification.
+            frequency: Operating frequency in Hz.
+            models_json: JSON object specifying which models to use (e.g., reluctance model).
+        
+        Returns:
+            JSON object with the inductance matrix at the specified frequency.
+        )pbdoc");
+    
+    m.def("calculate_leakage_inductance", &calculate_leakage_inductance,
+        R"pbdoc(
+        Calculate leakage inductance between windings.
+        
+        Computes the leakage inductance from a source winding to all other windings.
+        
+        Args:
+            magnetic_json: JSON object containing magnetic component specification.
+            frequency: Operating frequency in Hz.
+            source_index: Index of the source winding (0-based).
+        
+        Returns:
+            JSON object with leakage inductance values to each winding.
+        )pbdoc");
+    
+    m.def("calculate_dc_resistance_per_winding", &calculate_dc_resistance_per_winding,
+        R"pbdoc(
+        Calculate DC resistance for each winding.
+        
+        Computes the DC resistance of each winding based on wire properties
+        and temperature.
+        
+        Args:
+            coil_json: JSON object containing coil specification with turns and wire info.
+            temperature: Temperature in degrees Celsius for resistance calculation.
+        
+        Returns:
+            JSON array with DC resistance value for each winding in Ohms.
+        )pbdoc");
+    
+    m.def("calculate_resistance_matrix", &calculate_resistance_matrix,
+        R"pbdoc(
+        Calculate the resistance matrix for a magnetic component.
+        
+        Computes the frequency-dependent resistance matrix including self and mutual
+        resistances. Uses the Spreen (1990) method with inductance ratio scaling
+        for proper mutual resistance calculation.
+        
+        Args:
+            magnetic_json: JSON object containing magnetic component specification.
+            temperature: Temperature in degrees Celsius for resistance calculation.
+            frequency: Operating frequency in Hz.
+        
+        Returns:
+            JSON object with resistance matrix (magnitude and frequency).
+        )pbdoc");
+    
+    m.def("calculate_stray_capacitance", &calculate_stray_capacitance,
+        R"pbdoc(
+        Calculate stray capacitance for a coil.
+        
+        Computes turn-to-turn and winding-to-winding capacitances using the
+        specified capacitance model.
+        
+        Args:
+            coil_json: JSON object containing coil specification with turns.
+            operating_point_json: JSON object with operating conditions for voltage distribution.
+            models_json: JSON object specifying capacitance model (e.g., "Albach", "Koch").
+        
+        Returns:
+            JSON object with capacitance values including capacitance among turns,
+            capacitance among windings, and Maxwell capacitance matrix.
+        )pbdoc");
+    
+    m.def("calculate_maxwell_capacitance_matrix", &calculate_maxwell_capacitance_matrix,
+        R"pbdoc(
+        Calculate Maxwell capacitance matrix from inter-winding capacitances.
+        
+        Converts inter-winding capacitance values to the standard Maxwell
+        capacitance matrix format used in circuit simulation.
+        
+        Args:
+            coil_json: JSON object containing coil specification.
+            capacitance_among_windings_json: JSON object with capacitance values
+                between each pair of windings.
+        
+        Returns:
+            JSON array containing the Maxwell capacitance matrix.
+        )pbdoc");
 }
 
 } // namespace PyMKF

{pyopenmagnetics-1.1.0 → pyopenmagnetics-1.1.2}/src/simulation.h

@@ -20,6 +20,18 @@ json extract_operating_point(json fileJson, size_t numberWindings, double freque
 json extract_map_column_names(json fileJson, size_t numberWindings, double frequency);
 json extract_column_names(json fileJson);
 
+// Inductance calculations
+json calculate_inductance_matrix(json magneticJson, double frequency, json modelsData);
+json calculate_leakage_inductance(json magneticJson, double frequency, size_t sourceIndex);
+
+// Resistance calculations
+json calculate_dc_resistance_per_winding(json coilJson, double temperature);
+json calculate_resistance_matrix(json magneticJson, double temperature, double frequency);
+
+// Capacitance calculations
+json calculate_stray_capacitance(json coilJson, json operatingPointJson, json modelsData);
+json calculate_maxwell_capacitance_matrix(json coilJson, json capacitanceAmongWindingsJson);
+
 void register_simulation_bindings(py::module& m);
 
 } // namespace PyMKF