PyOpenMagnetics 1.4.4__tar.gz → 1.4.6__tar.gz

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

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

{pyopenmagnetics-1.4.4 → pyopenmagnetics-1.4.6}/PyOpenMagnetics.pyi

@@ -84,7 +84,7 @@ by reading AGENTS.md before starting.
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 """
 
-from typing import Dict, List, Any, Optional, Union, Literal
+from typing import Dict, List, Any, Optional, Union, Literal, overload
 
 # Type aliases for JSON-like structures
 JsonDict = Dict[str, Any]
@@ -373,12 +373,23 @@ def calculate_inductance_from_number_turns_and_gapping(
     """
     ...
 
+@overload
 def calculate_number_turns_from_gapping_and_inductance(
-    core: Core, 
-    inputs: Inputs, 
-    models: ModelsDict
+    core_data: Core,
+    coil_data: Coil,
+    inputs_data: Inputs,
+    models_data: ModelsDict
+) -> int:
+    """Calculate required turns for target inductance with given gap (coil-aware, preferred)."""
+    ...
+
+@overload
+def calculate_number_turns_from_gapping_and_inductance(
+    core_data: Core,
+    inputs_data: Inputs,
+    models_data: ModelsDict
 ) -> int:
-    """Calculate required turns for target inductance with given gap."""
+    """Legacy 3-argument form (no coil_data); synthesizes a single-primary-winding coil. Prefer the coil-aware overload."""
     ...
 
 def calculate_gapping_from_number_turns_and_inductance(

{pyopenmagnetics-1.4.4 → pyopenmagnetics-1.4.6}/llms.txt

@@ -230,10 +230,12 @@ L = PyOpenMagnetics.calculate_inductance_from_number_turns_and_gapping(
     core, coil, operating_point, models
 )
 
-# Calculate turns from inductance and gap
+# Calculate turns from inductance and gap (coil-aware, preferred)
 N = PyOpenMagnetics.calculate_number_turns_from_gapping_and_inductance(
-    core, inputs, models
+    core, coil, inputs, models
 )
+# Legacy 3-argument form (no coil) is still accepted for backward compatibility:
+# N = PyOpenMagnetics.calculate_number_turns_from_gapping_and_inductance(core, inputs, models)
 
 # Calculate gap from turns and inductance
 core_with_gap = PyOpenMagnetics.calculate_gapping_from_number_turns_and_inductance(

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

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

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

@@ -322,12 +322,34 @@ double calculate_inductance_from_number_turns_and_gapping(json coreData, json co
     return magnetizingInductance;
 }
 
-double calculate_number_turns_from_gapping_and_inductance(json coreData, json inputsData, json modelsData) {
+double calculate_number_turns_from_gapping_and_inductance(json coreData, json coilData, json inputsData, json modelsData) {
     OpenMagnetics::Core core(coreData);
+    OpenMagnetics::Coil coil(coilData);
     OpenMagnetics::Inputs inputs(inputsData);
 
     std::map<std::string, std::string> models = modelsData.get<std::map<std::string, std::string>>();
-    
+
+    auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
+    if (models.find("reluctance") != models.end()) {
+        OpenMagnetics::from_json(models["reluctance"], reluctanceModelName);
+    }
+
+    OpenMagnetics::MagnetizingInductance magnetizingInductanceObj(reluctanceModelName);
+    double numberTurns = magnetizingInductanceObj.calculate_number_turns_from_gapping_and_inductance(core, coil, &inputs);
+
+    return numberTurns;
+}
+
+// Legacy 3-argument variant (no coil_data). Backward-compat shim for callers
+// written before the coil parameter was added; forwards to MKF's 3-argument
+// overload, which synthesizes a single-primary-winding coil internally. New
+// code should pass coil_data and use the 4-argument form above.
+double calculate_number_turns_from_gapping_and_inductance_legacy(json coreData, json inputsData, json modelsData) {
+    OpenMagnetics::Core core(coreData);
+    OpenMagnetics::Inputs inputs(inputsData);
+
+    std::map<std::string, std::string> models = modelsData.get<std::map<std::string, std::string>>();
+
     auto reluctanceModelName = OpenMagnetics::defaults.reluctanceModelDefault;
     if (models.find("reluctance") != models.end()) {
         OpenMagnetics::from_json(models["reluctance"], reluctanceModelName);
@@ -960,14 +982,36 @@ void register_core_bindings(py::module& m) {
         
         Args:
             core_data: JSON object with core specification.
+            coil_data: JSON object with coil/winding specification.
             inputs_data: JSON Inputs with magnetizingInductance requirement.
             models_data: JSON dict with "reluctance" model selection.
-        
+
+        Returns:
+            Required number of turns (may be non-integer).
+        )pbdoc",
+        py::arg("core_data"), py::arg("coil_data"), py::arg("inputs_data"), py::arg("models_data"));
+
+    // Legacy 3-argument overload (no coil_data) registered under the SAME name:
+    // pybind dispatches by arity, so existing 3-arg callers keep working while
+    // new code uses the coil-aware 4-arg form above (the canonical default).
+    m.def("calculate_number_turns_from_gapping_and_inductance", &calculate_number_turns_from_gapping_and_inductance_legacy,
+        R"pbdoc(
+        Legacy variant of calculate_number_turns_from_gapping_and_inductance
+        without coil_data (kept for backward compatibility).
+
+        Synthesizes a single-primary-winding coil internally. Prefer the
+        coil-aware 4-argument form for multi-winding designs.
+
+        Args:
+            core_data: JSON object with core specification.
+            inputs_data: JSON Inputs with magnetizingInductance requirement.
+            models_data: JSON dict with "reluctance" model selection.
+
         Returns:
             Required number of turns (may be non-integer).
         )pbdoc",
         py::arg("core_data"), py::arg("inputs_data"), py::arg("models_data"));
-    
+
     m.def("calculate_gapping_from_number_turns_and_inductance", &calculate_gapping_from_number_turns_and_inductance,
         R"pbdoc(
         Calculate required gap from turns count and target inductance.

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

@@ -43,7 +43,8 @@ double calculate_temperature_from_core_thermal_resistance(json coreJson, double
 json calculate_gap_reluctance(json coreGapData, std::string modelNameString);
 json get_gap_reluctance_model_information();
 double calculate_inductance_from_number_turns_and_gapping(json coreData, json coilData, json operatingPointData, json modelsData);
-double calculate_number_turns_from_gapping_and_inductance(json coreData, json inputsData, json modelsData);
+double calculate_number_turns_from_gapping_and_inductance(json coreData, json coilData, json inputsData, json modelsData);
+double calculate_number_turns_from_gapping_and_inductance_legacy(json coreData, json inputsData, json modelsData);
 json calculate_gapping_from_number_turns_and_inductance(json coreData, json coilData, json inputsData, std::string gappingTypeJson, int decimals, json modelsData);
 
 // Shape queries by family/manufacturer

{pyopenmagnetics-1.4.4 → pyopenmagnetics-1.4.6}/src/utils.cpp

@@ -2,9 +2,10 @@
 
 namespace PyMKF {
 
-double resolve_dimension_with_tolerance(json dimensionWithToleranceJson) {
+double resolve_dimension_with_tolerance(json dimensionWithToleranceJson, std::string preferredValue) {
     DimensionWithTolerance dimensionWithTolerance(dimensionWithToleranceJson);
-    return OpenMagnetics::resolve_dimensional_values(dimensionWithTolerance);
+    OpenMagnetics::DimensionalValues preferred = json(preferredValue).get<OpenMagnetics::DimensionalValues>();
+    return OpenMagnetics::resolve_dimensional_values(dimensionWithTolerance, preferred);
 }
 
 json calculate_basic_processed_data(json waveformJson) {
@@ -347,16 +348,19 @@ void register_utils_bindings(py::module& m) {
     m.def("resolve_dimension_with_tolerance", &resolve_dimension_with_tolerance,
         R"pbdoc(
         Resolve a dimension specification that may include tolerances.
-        
+
         Extracts a single value from dimension data that may contain
         nominal, minimum, and maximum values.
-        
+
         Args:
             dimension_json: JSON object with dimension specification.
-        
+            preferred: Which value to prefer when present — "Nominal" (default),
+                "Maximum", or "Minimum".
+
         Returns:
             Resolved dimension value as float.
-        )pbdoc");
+        )pbdoc",
+        py::arg("dimensionWithToleranceJson"), py::arg("preferredValue") = "Nominal");
     
     m.def("calculate_basic_processed_data", &calculate_basic_processed_data,
         R"pbdoc(

{pyopenmagnetics-1.4.4 → pyopenmagnetics-1.4.6}/src/utils.h

@@ -4,7 +4,7 @@
 namespace PyMKF {
 
 // Utility functions for processing and calculations
-double resolve_dimension_with_tolerance(json dimensionWithToleranceJson);
+double resolve_dimension_with_tolerance(json dimensionWithToleranceJson, std::string preferredValue = "Nominal");
 json calculate_basic_processed_data(json waveformJson);
 json calculate_harmonics(json waveformJson, double frequency);
 json calculate_sampled_waveform(json waveformJson, double frequency);