emachines 0.1.0__tar.gz

emachines-0.1.0/.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+venv/
+env/
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb_checkpoints
+
+# nbdev
+/_docs/
+/docs/_proc/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Distribution
+dist/
+*.whl
+*.tar.gz
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# macOS
+.DS_Store
+
+# Secrets
+.env
+*.env

emachines-0.1.0/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to `emachines` will be documented here.
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+Versioning follows [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+- FSCW winding factors via star-of-slots phasor method (migration from emdesigner)
+- `emachines.winding.sos`: star-of-slots module
+- `emachines.winding.mmf`: MMF harmonic spectrum
+- PyPI registration
+
+## [0.1.0] — 2026-05-07
+### Added
+- `emachines.winding.factors`: pitch factor (kp), distribution factor (kd), winding factor (kw)
+  - Integer-slot windings (q ≥ 1) fully supported
+  - FSCW (q < 1) raises ValueError with clear message — star-of-slots pending
+- `emachines.magnetics.bh_models`: Fröhlich analytical BH model and curve fitting
+- `emachines.magnetics.iron_loss`: Steinmetz and Bertotti three-term separation models
+- `emachines.motors.pmsm`: PMSMParams dataclass, back-EMF, torque (excitation + reluctance), steady-state dq current solver
+- 18 passing tests, 4 xfailed (FSCW — by design, pending star-of-slots migration)
+- `pyproject.toml`: hatchling build, PyPI metadata, Python ≥ 3.9
+- `settings.ini`: nbdev-ready configuration
+- MIT License
+
+### Fixed
+- Corrected GitHub username in project URLs (`vnaveendeepak` → `NaveenDeepak`)
+- Lowered minimum Python from 3.10 to 3.9 to match emdesigner Docker environment

emachines-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ND
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

emachines-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: emachines
+Version: 0.1.0
+Summary: Analytical electromechanical machine design library
+Project-URL: Homepage, https://emdesignlabs.com
+Project-URL: Repository, https://github.com/NaveenDeepak/emachines
+Project-URL: Documentation, https://NaveenDeepak.github.io/emachines
+Author-email: ND <NaveenDeepak@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: BLDC,MMF,PMSM,electric motor,electromagnetic,electromechanical,motor design,winding,winding factor
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Provides-Extra: dev
+Requires-Dist: jupyter; extra == 'dev'
+Requires-Dist: nbdev; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: nbdev; extra == 'docs'
+Requires-Dist: quarto; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# emachines
+
+**Analytical electromechanical machine design library.**
+
+`emachines` is the core physics and mathematics engine behind [emdesignlabs.com](https://emdesignlabs.com). It provides well-documented, tested, and citable implementations of the analytical models used in electric motor design.
+
+## Scope
+
+- **Winding analysis** — winding factors (kp, kd, kw), MMF harmonic spectra, slot/pole geometry
+- **Magnetics** — BH curve models (Fröhlich, Jiles-Atherton), iron loss (Steinmetz, Bertotti)
+- **Motor models** — PMSM dq-frame, DC motor, surface-PM analytical design
+
+Every function documents the equation it implements and its bibliographic source.
+
+## Installation
+
+```bash
+pip install emachines
+```
+
+For development (editable install alongside emdesignlabs):
+
+```bash
+pip install -e path/to/emachines
+```
+
+## Quick Start
+
+```python
+from emachines.winding.factors import winding_factor
+from emachines.magnetics.iron_loss import bertotti
+from emachines.motors.pmsm import PMSMParams, torque
+
+# Winding factor for 12s/10p, fundamental harmonic
+kw1 = winding_factor(nu=1, Q=12, p=5, coil_span=1)
+print(f"kw1 = {kw1:.4f}")  # → 0.9330
+
+# Bertotti iron loss at 400 Hz, 1.5 T
+loss = bertotti(f=400, B_peak=1.5, k_h=0.02, k_e=1e-4, k_a=1e-3)
+print(f"Total loss = {loss['total']:.2f} W/kg")
+
+# PMSM torque from dq currents
+motor = PMSMParams(p=3, Ld=5e-3, Lq=8e-3, psi_m=0.15)
+Te = torque(motor, id=-3.0, iq=10.0)
+print(f"Torque = {Te:.2f} N·m")
+```
+
+## Design Philosophy
+
+- **Equations first** — every function documents the formula it implements with LaTeX notation
+- **Cited** — every formula traces back to a specific reference (textbook, paper, standard)
+- **Tested** — validated against published datasets and reference tools (emetor, SWAT-EM)
+- **Dependency-light** — only numpy and scipy required
+
+## Status
+
+`0.1.x` — Alpha. API may change between minor versions.
+
+## License
+
+MIT

emachines-0.1.0/README.md

@@ -0,0 +1,61 @@
+# emachines
+
+**Analytical electromechanical machine design library.**
+
+`emachines` is the core physics and mathematics engine behind [emdesignlabs.com](https://emdesignlabs.com). It provides well-documented, tested, and citable implementations of the analytical models used in electric motor design.
+
+## Scope
+
+- **Winding analysis** — winding factors (kp, kd, kw), MMF harmonic spectra, slot/pole geometry
+- **Magnetics** — BH curve models (Fröhlich, Jiles-Atherton), iron loss (Steinmetz, Bertotti)
+- **Motor models** — PMSM dq-frame, DC motor, surface-PM analytical design
+
+Every function documents the equation it implements and its bibliographic source.
+
+## Installation
+
+```bash
+pip install emachines
+```
+
+For development (editable install alongside emdesignlabs):
+
+```bash
+pip install -e path/to/emachines
+```
+
+## Quick Start
+
+```python
+from emachines.winding.factors import winding_factor
+from emachines.magnetics.iron_loss import bertotti
+from emachines.motors.pmsm import PMSMParams, torque
+
+# Winding factor for 12s/10p, fundamental harmonic
+kw1 = winding_factor(nu=1, Q=12, p=5, coil_span=1)
+print(f"kw1 = {kw1:.4f}")  # → 0.9330
+
+# Bertotti iron loss at 400 Hz, 1.5 T
+loss = bertotti(f=400, B_peak=1.5, k_h=0.02, k_e=1e-4, k_a=1e-3)
+print(f"Total loss = {loss['total']:.2f} W/kg")
+
+# PMSM torque from dq currents
+motor = PMSMParams(p=3, Ld=5e-3, Lq=8e-3, psi_m=0.15)
+Te = torque(motor, id=-3.0, iq=10.0)
+print(f"Torque = {Te:.2f} N·m")
+```
+
+## Design Philosophy
+
+- **Equations first** — every function documents the formula it implements with LaTeX notation
+- **Cited** — every formula traces back to a specific reference (textbook, paper, standard)
+- **Tested** — validated against published datasets and reference tools (emetor, SWAT-EM)
+- **Dependency-light** — only numpy and scipy required
+
+## Status
+
+`0.1.x` — Alpha. API may change between minor versions.
+
+## License
+
+MIT

emachines-0.1.0/emachines/__init__.py

@@ -0,0 +1,4 @@
+"""emachines — Analytical electromechanical machine design library."""
+
+__version__ = "0.1.0"
+__all__ = []

emachines-0.1.0/emachines/magnetics/__init__.py

@@ -0,0 +1 @@
+"""Magnetics: BH curve models, iron loss, PM demagnetization."""

emachines-0.1.0/emachines/magnetics/bh_models.py

@@ -0,0 +1,76 @@
+"""
+BH curve models for soft magnetic materials.
+
+Provides analytical fits to measured BH data and standard
+approximation models used in motor design.
+
+References:
+    Jiles, D.C., Atherton, D.L. (1986). Theory of ferromagnetic hysteresis.
+        Journal of Magnetism and Magnetic Materials, 61(1-2), 48-60.
+    Frölhich, O. (1881). Investigations of dynamoelectric machines.
+        Elektrotechnische Zeitschrift.
+"""
+
+import numpy as np
+from scipy.optimize import curve_fit
+
+__all__ = ["frolich", "fit_frolich", "linear_region"]
+
+
+def frolich(H: np.ndarray, a: float, b: float) -> np.ndarray:
+    r"""
+    Fröhlich-Kennelly analytical BH approximation.
+
+    .. math::
+        B = \frac{H}{a + b \cdot |H|}
+
+    Simple two-parameter model. Accurate for moderate flux densities.
+    Breaks down near and above saturation.
+
+    Args:
+        H: Magnetic field intensity (A/m), array-like
+        a: Model parameter (dimensionless)
+        b: Model parameter (m/A)
+
+    Returns:
+        Flux density B (T)
+
+    References:
+        Fröhlich (1881); see also Hanselman (2003), §3.2
+    """
+    H = np.asarray(H, dtype=float)
+    return H / (a + b * np.abs(H))
+
+
+def fit_frolich(H: np.ndarray, B: np.ndarray) -> tuple[float, float]:
+    """
+    Fit Fröhlich model parameters (a, b) to measured BH data.
+
+    Args:
+        H: Measured field intensity values (A/m)
+        B: Measured flux density values (T)
+
+    Returns:
+        Tuple (a, b) of fitted parameters
+    """
+    H = np.asarray(H, dtype=float)
+    B = np.asarray(B, dtype=float)
+    (a, b), _ = curve_fit(frolich, H, B, p0=[1.0, 1.0], maxfev=5000)
+    return float(a), float(b)
+
+
+def linear_region(H: np.ndarray, mu_r: float) -> np.ndarray:
+    r"""
+    Linear BH approximation: B = μ₀ · μr · H
+
+    Valid for low flux densities well below saturation.
+
+    Args:
+        H:    Magnetic field intensity (A/m)
+        mu_r: Relative permeability
+
+    Returns:
+        Flux density B (T)
+    """
+    MU_0 = 4 * np.pi * 1e-7
+    return MU_0 * mu_r * np.asarray(H, dtype=float)

emachines-0.1.0/emachines/magnetics/iron_loss.py

@@ -0,0 +1,97 @@
+"""
+Iron (core) loss models.
+
+Covers the classical Steinmetz equation, the improved generalized
+Steinmetz equation (iGSE), and Bertotti's three-term separation model.
+
+References:
+    Steinmetz, C.P. (1892). On the law of hysteresis.
+        AIEE Transactions, 9, 3-64.
+    Bertotti, G. (1988). General properties of power losses in soft
+        ferromagnetic materials. IEEE Trans. Magnetics, 24(1), 621-630.
+    Venkatachalam, K. et al. (2002). Accurate prediction of ferrite core
+        loss with nonsinusoidal waveforms. COMPEL, 21(4).
+"""
+
+import numpy as np
+
+__all__ = ["steinmetz", "bertotti"]
+
+
+def steinmetz(
+    f: float,
+    B_peak: float,
+    k_h: float,
+    alpha: float,
+    beta: float,
+) -> float:
+    r"""
+    Classical Steinmetz core loss model (per unit mass).
+
+    .. math::
+        P_{core} = k_h \cdot f^{\alpha} \cdot \hat{B}^{\beta}
+
+    Valid for sinusoidal excitation. Parameters k_h, α, β are
+    material-specific and typically obtained by curve fitting to
+    manufacturer loss data.
+
+    Args:
+        f:      Electrical frequency (Hz)
+        B_peak: Peak flux density (T)
+        k_h:    Hysteresis loss coefficient
+        alpha:  Frequency exponent (typically 1.0–1.6)
+        beta:   Flux density exponent (typically 1.6–2.2)
+
+    Returns:
+        Core loss power density (W/kg)
+
+    References:
+        Steinmetz (1892); Bertotti (1988)
+    """
+    return k_h * (f ** alpha) * (B_peak ** beta)
+
+
+def bertotti(
+    f: float,
+    B_peak: float,
+    k_h: float,
+    k_e: float,
+    k_a: float,
+    alpha: float = 1.0,
+    beta: float = 2.0,
+) -> dict[str, float]:
+    r"""
+    Bertotti three-term iron loss separation model (per unit mass).
+
+    Separates total loss into hysteresis, classical eddy current,
+    and excess (anomalous) loss components:
+
+    .. math::
+        P_{total} = \underbrace{k_h f \hat{B}^{\beta}}_{hysteresis}
+                  + \underbrace{k_e f^2 \hat{B}^2}_{eddy}
+                  + \underbrace{k_a f^{1.5} \hat{B}^{1.5}}_{excess}
+
+    Args:
+        f:      Electrical frequency (Hz)
+        B_peak: Peak flux density (T)
+        k_h:    Hysteresis loss coefficient (W·s/kg)
+        k_e:    Eddy current loss coefficient (W·s²/kg)
+        k_a:    Excess loss coefficient (W·s^1.5/kg)
+        alpha:  Frequency exponent for hysteresis (default 1.0)
+        beta:   Flux density exponent for hysteresis (default 2.0)
+
+    Returns:
+        Dict with keys: 'hysteresis', 'eddy', 'excess', 'total' (W/kg)
+
+    References:
+        Bertotti (1988), eq. 6
+    """
+    p_hyst = k_h * (f ** alpha) * (B_peak ** beta)
+    p_eddy = k_e * (f ** 2) * (B_peak ** 2)
+    p_exc  = k_a * (f ** 1.5) * (B_peak ** 1.5)
+    return {
+        "hysteresis": p_hyst,
+        "eddy":       p_eddy,
+        "excess":     p_exc,
+        "total":      p_hyst + p_eddy + p_exc,
+    }

emachines-0.1.0/emachines/motors/__init__.py

@@ -0,0 +1 @@
+"""Motor models: PMSM dq-model, DC motor, SPM."""

emachines-0.1.0/emachines/motors/pmsm.py

@@ -0,0 +1,143 @@
+"""
+Permanent Magnet Synchronous Machine (PMSM) — dq-frame model.
+
+Covers steady-state torque, power, back-EMF, and per-unit
+dq-axis equations for surface-mount (SPM) and interior (IPM) variants.
+
+References:
+    Hanselman, D.C. (2003). Brushless Permanent Magnet Motor Design. 2nd ed.
+    Mohan, N. (2011). Advanced Electric Drives. Wiley.
+    Pyrhönen, J. et al. (2008). Design of Rotating Electrical Machines.
+"""
+
+import numpy as np
+
+__all__ = ["back_emf", "torque", "dq_currents", "PMSMParams"]
+
+
+class PMSMParams:
+    """
+    Container for PMSM parameters.
+
+    Attributes:
+        p:      Number of pole pairs
+        Ld:     d-axis inductance (H)
+        Lq:     q-axis inductance (H)
+        psi_m:  Permanent magnet flux linkage (Wb)
+        Rs:     Stator resistance per phase (Ω)
+        J:      Rotor inertia (kg·m²)
+    """
+
+    def __init__(
+        self,
+        p: int,
+        Ld: float,
+        Lq: float,
+        psi_m: float,
+        Rs: float = 0.0,
+        J: float = 0.0,
+    ):
+        self.p = p
+        self.Ld = Ld
+        self.Lq = Lq
+        self.psi_m = psi_m
+        self.Rs = Rs
+        self.J = J
+
+    @property
+    def is_spm(self) -> bool:
+        """True if surface-mount (Ld ≈ Lq, no reluctance torque)."""
+        return np.isclose(self.Ld, self.Lq, rtol=0.05)
+
+
+def back_emf(omega_e: float, psi_m: float) -> float:
+    r"""
+    Peak phase back-EMF for a PMSM.
+
+    .. math::
+        E = \omega_e \cdot \psi_m
+
+    Args:
+        omega_e: Electrical angular velocity (rad/s)
+        psi_m:   PM flux linkage (Wb)
+
+    Returns:
+        Peak back-EMF (V)
+
+    References:
+        Hanselman (2003), eq. 7.3
+    """
+    return omega_e * psi_m
+
+
+def torque(
+    params: PMSMParams,
+    id: float,
+    iq: float,
+) -> float:
+    r"""
+    Electromagnetic torque from dq-frame currents.
+
+    .. math::
+        T_e = \frac{3}{2} p \left[\psi_m i_q + (L_d - L_q) i_d i_q \right]
+
+    First term: excitation (alignment) torque.
+    Second term: reluctance torque (zero for SPM where Ld = Lq).
+
+    Args:
+        params: PMSMParams instance
+        id:     d-axis current (A)
+        iq:     q-axis current (A)
+
+    Returns:
+        Electromagnetic torque Te (N·m)
+
+    References:
+        Hanselman (2003), eq. 7.10; Mohan (2011), §5.4
+    """
+    T_excitation = params.psi_m * iq
+    T_reluctance = (params.Ld - params.Lq) * id * iq
+    return 1.5 * params.p * (T_excitation + T_reluctance)
+
+
+def dq_currents(
+    params: PMSMParams,
+    omega_e: float,
+    Vd: float,
+    Vq: float,
+) -> tuple[float, float]:
+    r"""
+    Steady-state dq currents from applied dq voltages.
+
+    Solves the steady-state voltage equations:
+
+    .. math::
+        V_d = R_s i_d - \omega_e L_q i_q
+
+    .. math::
+        V_q = R_s i_q + \omega_e (L_d i_d + \psi_m)
+
+    Args:
+        params:  PMSMParams instance
+        omega_e: Electrical angular velocity (rad/s)
+        Vd:      d-axis voltage (V)
+        Vq:      q-axis voltage (V)
+
+    Returns:
+        Tuple (id, iq) in amperes
+
+    References:
+        Pyrhönen et al. (2008), §7.3
+    """
+    Rs = params.Rs
+    Ld = params.Ld
+    Lq = params.Lq
+    psi_m = params.psi_m
+    we = omega_e
+
+    # 2x2 linear system: [Rs, -we*Lq; we*Ld, Rs] · [id; iq] = [Vd; Vq - we*psi_m]
+    A = np.array([[Rs, -we * Lq],
+                  [we * Ld, Rs]])
+    b = np.array([Vd, Vq - we * psi_m])
+    id_, iq_ = np.linalg.solve(A, b)
+    return float(id_), float(iq_)

emachines-0.1.0/emachines/winding/__init__.py

@@ -0,0 +1 @@
+"""Winding analysis: factors, MMF harmonics, slot/pole geometry."""

emachines-0.1.0/emachines/winding/factors.py

@@ -0,0 +1,105 @@
+"""
+Winding factor calculations.
+
+Covers pitch factor (kp), distribution factor (kd), and combined
+winding factor kw = kp · kd for the ν-th harmonic.
+
+Current scope:
+    - Integer-slot windings (q ≥ 1): full support
+    - Fractional-slot concentrated windings (FSCW, q < 1):
+      requires the star-of-slots method — to be migrated from emdesigner.
+      Attempting to use distribution_factor() with q < 1 raises ValueError.
+
+References:
+    Hanselman, D.C. (2003). Brushless Permanent Magnet Motor Design. 2nd ed.
+    Pyrhönen, J., Jokinen, T., Hrabovcová, V. (2008). Design of Rotating Electrical Machines.
+"""
+
+import numpy as np
+
+__all__ = ["pitch_factor", "distribution_factor", "winding_factor"]
+
+
+def pitch_factor(nu: int, coil_span: int, pole_pitch: float) -> float:
+    r"""
+    Pitch (chording) factor kp for the ν-th harmonic.
+
+    .. math::
+        k_{p\nu} = \sin\!\left(\nu \cdot \frac{\pi}{2} \cdot \frac{y}{\tau_p}\right)
+
+    Args:
+        nu:         Harmonic order ν (1 = fundamental)
+        coil_span:  Coil span in slots (y)
+        pole_pitch: Pole pitch in slots (τp = Q / P)
+
+    Returns:
+        Pitch factor kp ∈ [0, 1]
+
+    References:
+        Hanselman (2003), eq. 4.5
+    """
+    return float(np.abs(np.sin(nu * np.pi / 2 * coil_span / pole_pitch)))
+
+
+def distribution_factor(nu: int, Q: int, p: int, m: int = 3) -> float:
+    r"""
+    Distribution (belt) factor kd for the ν-th harmonic.
+
+    Valid for integer-slot windings only (q = Q/(2mp) ≥ 1).
+    For FSCW (q < 1), use the star-of-slots phasor method instead
+    (not yet implemented — tracked for migration from emdesigner).
+
+    .. math::
+        k_{d\nu} = \frac{\sin(\nu \cdot \pi / (2m))}{q \cdot \sin(\nu \cdot \pi / (2mq))}
+
+    Args:
+        nu: Harmonic order ν
+        Q:  Total number of slots
+        p:  Number of pole pairs
+        m:  Number of phases (default 3)
+
+    Returns:
+        Distribution factor kd ∈ (0, 1]
+
+    Raises:
+        ValueError: If q < 1 (FSCW — use star-of-slots method instead)
+
+    References:
+        Pyrhönen et al. (2008), eq. 2.15
+    """
+    q = Q / (2 * m * p)
+    if q < 1.0 - 1e-9:
+        raise ValueError(
+            f"distribution_factor() requires q ≥ 1 (integer-slot winding). "
+            f"Got q = {q:.4f} (Q={Q}, p={p}, m={m}). "
+            f"For FSCW use the star-of-slots method (coming soon in emachines.winding.sos)."
+        )
+    num = np.sin(nu * np.pi / (2 * m))
+    den = q * np.sin(nu * np.pi / (2 * m * q))
+    if np.abs(den) < 1e-12:
+        return 1.0
+    return float(np.abs(num / den))
+
+
+def winding_factor(nu: int, Q: int, p: int, coil_span: int, m: int = 3) -> float:
+    r"""
+    Combined winding factor kw = kp · kd for the ν-th harmonic.
+
+    Integer-slot windings only. For FSCW (Q/(2mp) < 1) this raises
+    ValueError — the star-of-slots method is needed and will be
+    provided in emachines.winding.sos once migrated from emdesigner.
+
+    Args:
+        nu:         Harmonic order ν (1 = fundamental)
+        Q:          Total number of slots
+        p:          Number of pole pairs
+        coil_span:  Coil span in slots
+        m:          Number of phases (default 3)
+
+    Returns:
+        Winding factor kw ∈ [0, 1]
+    """
+    pole_pitch = Q / (2 * p)
+    kp = pitch_factor(nu, coil_span, pole_pitch)
+    kd = distribution_factor(nu, Q, p, m)
+    return kp * kd

emachines-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "emachines"
+version = "0.1.0"
+description = "Analytical electromechanical machine design library"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "ND", email = "NaveenDeepak@gmail.com" }]
+keywords = [
+    "electric motor", "PMSM", "BLDC", "winding", "electromagnetic",
+    "electromechanical", "motor design", "winding factor", "MMF"
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "numpy>=1.24",
+    "scipy>=1.10",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "nbdev",
+    "jupyter",
+]
+docs = [
+    "nbdev",
+    "quarto",
+]
+
+[project.urls]
+Homepage = "https://emdesignlabs.com"
+Repository = "https://github.com/NaveenDeepak/emachines"
+Documentation = "https://NaveenDeepak.github.io/emachines"
+
+[tool.hatch.build.targets.wheel]
+packages = ["emachines"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--tb=short"

emachines-0.1.0/settings.ini

@@ -0,0 +1,22 @@
+[DEFAULT]
+# nbdev settings
+lib_name = emachines
+user = NaveenDeepak
+author = ND
+author_email = NaveenDeepak@gmail.com
+description = Analytical electromechanical machine design library
+keywords = electric motor PMSM BLDC winding electromagnetic electromechanical
+license = apache2
+copyright = ND
+branch = main
+version = 0.1.0
+min_python = 3.9
+audience = Science/Research
+language = English
+custom_sidebar = false
+nbs_path = nbs
+lib_path = emachines
+doc_path = docs
+doc_host = https://NaveenDeepak.github.io
+doc_baseurl = /emachines
+git_url = https://github.com/NaveenDeepak/emachines

emachines-0.1.0/tests/test_iron_loss.py

@@ -0,0 +1,32 @@
+"""Tests for iron loss models."""
+
+import numpy as np
+from emachines.magnetics.iron_loss import steinmetz, bertotti
+
+
+def test_steinmetz_scales_with_frequency():
+    """Loss increases with frequency."""
+    p1 = steinmetz(50, 1.0, k_h=0.01, alpha=1.5, beta=2.0)
+    p2 = steinmetz(100, 1.0, k_h=0.01, alpha=1.5, beta=2.0)
+    assert p2 > p1
+
+
+def test_steinmetz_scales_with_flux():
+    """Loss increases with flux density."""
+    p1 = steinmetz(50, 1.0, k_h=0.01, alpha=1.5, beta=2.0)
+    p2 = steinmetz(50, 1.5, k_h=0.01, alpha=1.5, beta=2.0)
+    assert p2 > p1
+
+
+def test_bertotti_total_equals_sum_of_components():
+    """Total loss = hysteresis + eddy + excess."""
+    result = bertotti(50, 1.5, k_h=0.02, k_e=1e-4, k_a=1e-3)
+    expected = result["hysteresis"] + result["eddy"] + result["excess"]
+    assert np.isclose(result["total"], expected)
+
+
+def test_bertotti_all_components_positive():
+    result = bertotti(400, 1.0, k_h=0.01, k_e=5e-5, k_a=5e-4)
+    assert result["hysteresis"] > 0
+    assert result["eddy"] > 0
+    assert result["excess"] > 0

emachines-0.1.0/tests/test_pmsm.py

@@ -0,0 +1,59 @@
+"""Tests for PMSM dq-model."""
+
+import numpy as np
+import pytest
+from emachines.motors.pmsm import PMSMParams, back_emf, torque, dq_currents
+
+
+@pytest.fixture
+def spm():
+    """Typical SPM parameters (Ld = Lq)."""
+    return PMSMParams(p=3, Ld=5e-3, Lq=5e-3, psi_m=0.15, Rs=0.5)
+
+
+@pytest.fixture
+def ipm():
+    """Typical IPM parameters (Ld < Lq)."""
+    return PMSMParams(p=4, Ld=3e-3, Lq=8e-3, psi_m=0.12, Rs=0.3)
+
+
+def test_back_emf(spm):
+    """E = omega_e * psi_m"""
+    omega_e = 2 * np.pi * 50 * spm.p  # electrical rad/s at 50 Hz mechanical
+    E = back_emf(omega_e, spm.psi_m)
+    assert E > 0
+    assert np.isclose(E, omega_e * spm.psi_m)
+
+
+def test_spm_torque_no_reluctance(spm):
+    """SPM: reluctance torque = 0, Te depends only on iq."""
+    Te_1 = torque(spm, id=0.0, iq=10.0)
+    Te_2 = torque(spm, id=-5.0, iq=10.0)
+    # For SPM (Ld=Lq), id has no effect on torque
+    assert np.isclose(Te_1, Te_2, atol=1e-10)
+
+
+def test_ipm_reluctance_torque(ipm):
+    """IPM: negative id adds reluctance torque (MTPA region)."""
+    Te_id0  = torque(ipm, id=0.0,  iq=10.0)
+    Te_mtpa = torque(ipm, id=-5.0, iq=10.0)
+    assert Te_mtpa > Te_id0  # reluctance torque boosts total torque
+
+
+def test_torque_sign(spm):
+    """Positive iq → positive torque (motoring)."""
+    assert torque(spm, id=0.0, iq=5.0) > 0
+    assert torque(spm, id=0.0, iq=-5.0) < 0
+
+
+def test_dq_currents_steady_state(spm):
+    """Steady-state currents should satisfy voltage equations."""
+    omega_e = 2 * np.pi * 100.0
+    Vd, Vq = 0.0, 100.0
+    id_, iq_ = dq_currents(spm, omega_e, Vd, Vq)
+
+    # Verify voltage equations
+    Vd_check = spm.Rs * id_ - omega_e * spm.Lq * iq_
+    Vq_check = spm.Rs * iq_ + omega_e * (spm.Ld * id_ + spm.psi_m)
+    assert np.isclose(Vd_check, Vd, atol=1e-6)
+    assert np.isclose(Vq_check, Vq, atol=1e-6)

emachines-0.1.0/tests/test_winding.py

@@ -0,0 +1,75 @@
+"""
+Tests for winding factor calculations.
+
+Reference values validated against emetor.com and SWAT-EM.
+"""
+
+import pytest
+import numpy as np
+from emachines.winding.factors import pitch_factor, distribution_factor, winding_factor
+
+
+class TestPitchFactor:
+    def test_full_pitch_fundamental(self):
+        """Full-pitch coil: kp1 = 1.0"""
+        assert np.isclose(pitch_factor(1, 3, 3.0), 1.0)
+
+    def test_chorded_coil(self):
+        """5/6 chording: kp1 = sin(5π/12) ≈ 0.9659"""
+        assert np.isclose(pitch_factor(1, 5, 6.0), np.sin(5 * np.pi / 12), atol=1e-4)
+
+    def test_third_harmonic_elimination(self):
+        """2/3 chording eliminates 3rd harmonic: kp3 = 0"""
+        assert np.isclose(pitch_factor(3, 4, 6.0), 0.0, atol=1e-10)
+
+
+class TestDistributionFactor:
+    def test_q1_concentrated(self):
+        """q=1: kd1 = 1.0"""
+        # Q=6, p=1, m=3 → q=1
+        assert np.isclose(distribution_factor(1, 6, 1, m=3), 1.0)
+
+    def test_q2_distributed(self):
+        """q=2: kd1 ≈ 0.9659"""
+        # Q=12, p=1, m=3 → q=2
+        assert np.isclose(distribution_factor(1, 12, 1, m=3), 0.9659, atol=1e-3)
+
+    def test_fscw_raises(self):
+        """FSCW (q < 1) raises ValueError — star-of-slots not yet implemented."""
+        # Q=12, p=5, m=3 → q=0.4
+        with pytest.raises(ValueError, match="star-of-slots"):
+            distribution_factor(1, 12, 5, m=3)
+
+
+class TestWindingFactorIntegerSlot:
+    @pytest.mark.parametrize("Q,p,coil_span,expected_kw1", [
+        (24, 2, 5, 0.9330),   # 24s/4p, 5/6 chording: kp=0.9659, kd=0.9659
+        (36, 3, 5, 0.9330),   # 36s/6p, 5/6 chording: same q=2, same result
+        (12, 1, 6, 0.9659),   # 12s/2p, full pitch (coil_span=pole_pitch=6): kp=1.0, kd=0.9659
+    ])
+    def test_integer_slot_kw1(self, Q, p, coil_span, expected_kw1):
+        kw = winding_factor(1, Q, p, coil_span)
+        assert np.isclose(kw, expected_kw1, atol=0.001), \
+            f"Q={Q}, p={p}, coil_span={coil_span}: kw1={kw:.4f}, expected≈{expected_kw1}"
+
+
+class TestWindingFactorFSCW:
+    @pytest.mark.xfail(
+        reason="FSCW requires star-of-slots phasor method — "
+               "to be migrated from emdesigner.winding_engine",
+        raises=ValueError,
+        strict=True,
+    )
+    @pytest.mark.parametrize("Q,P,expected_kw1", [
+        (12, 10, 0.933),
+        (12,  8, 0.866),
+        ( 9,  8, 0.945),
+        (12, 14, 0.933),
+    ])
+    def test_fscw_kw1(self, Q, P, expected_kw1):
+        """FSCW winding factors — xfail until star-of-slots is ported."""
+        p = P // 2
+        pole_pitch = Q / P
+        coil_span = max(1, round(pole_pitch))
+        kw = winding_factor(1, Q, p, coil_span)
+        assert np.isclose(kw, expected_kw1, atol=0.01)