PyOpenMagnetics 1.4.5__tar.gz → 1.4.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyOpenMagnetics
-Version: 1.4.5
+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.5 → 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.5 → 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.5 → pyopenmagnetics-1.4.6}/pyproject.toml

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

{pyopenmagnetics-1.4.5 → 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.5 → 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