cfsem 2.4.3__tar.gz → 2.5.0__tar.gz

{cfsem-2.4.3 → cfsem-2.5.0}/.github/workflows/test_python.yml

@@ -5,7 +5,10 @@ name: test_python
 
 on: 
   # push: []  # Save time on actions
-  pull_request: []
+  pull_request:
+    branches: [ "*" ]
+  push:
+    branches: [ "main", "develop", "release" ]
   workflow_dispatch:
     tag: "Manual Run"
   workflow_call:

{cfsem-2.4.3 → cfsem-2.5.0}/CHANGELOG_PYTHON.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 2.5.0 2025-08-05
+
+### Added
+
+* Add `solenoid_stress` module
+  * 1D finite-difference solver for solenoid stress given arbitrary B-field, current density, and surface load
+    * Generalizes over both long-solenoid stress and ideal thick-walled pressure vessel stress
+    * Tested against handcalcs for both ideal solenoid & thick-walled pressure vessel
+  * 1D handcalc for solenoid stress under uniform current density and linear B-field profile
+  * 1D handcalc for thick-walled pressure vessel
+
 ## 2.4.3 2025-07-07
 
 ### Changed

{cfsem-2.4.3 → cfsem-2.5.0}/CHANGELOG_RUST.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 2.4.3 2025-07-07
+## 2.4.3 2025-07-07, 2.5.0 2025-08-05
 
 ### Changed
 

{cfsem-2.4.3 → cfsem-2.5.0}/Cargo.lock

@@ -64,7 +64,7 @@ checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
 
 [[package]]
 name = "cfsem"
-version = "2.4.3"
+version = "2.5.0"
 dependencies = [
  "criterion",
  "itertools 0.14.0",

{cfsem-2.4.3 → cfsem-2.5.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cfsem"
-version = "2.4.3"
+version = "2.5.0"
 edition = "2024"
 authors = ["Commonwealth Fusion Systems <jlogan@cfs.energy>"]
 license = "MIT"

cfsem-2.5.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: cfsem
+Version: 2.5.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: numpy>=2
+Requires-Dist: interpn>=0.2.5
+Requires-Dist: findiff>=0.12.1
+Requires-Dist: pydantic>=2
+Requires-Dist: pydantic-numpy>=6
+Requires-Dist: pytest>=7.1.3 ; extra == 'dev'
+Requires-Dist: coverage>=6.5.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.6.2 ; extra == 'dev'
+Requires-Dist: pyright==1.1.402 ; extra == 'dev'
+Requires-Dist: scipy>=1.8 ; extra == 'dev'
+Requires-Dist: mkdocs>=1.6.0 ; extra == 'dev'
+Requires-Dist: mkdocs-material>=9.5.25 ; extra == 'dev'
+Requires-Dist: mkdocstrings[python]>=0.25.1 ; extra == 'dev'
+Requires-Dist: matplotlib>=3.9 ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+Summary: Quasi-steady electromagnetics including filamentized approximations, Biot-Savart, and Grad-Shafranov.
+Home-Page: https://github.com/cfs-energy/cfsem-py
+Author-email: Commonwealth Fusion Systems <jlogan@cfs.energy>
+License-Expression: MIT
+Requires-Python: >=3.9, <3.14

cfsem-2.5.0/cfsem/solenoid_stress/solenoid_1d.py

@@ -0,0 +1,317 @@
+"""
+Finite-difference solution to structural PDE for pancake or
+infinite-length solenoid coil, following Iwasa 2e section 3.6.
+
+Assumes
+* Uniform current density within each r-section
+* Zero R-Z shear (deck-of-cards structure)
+* Zero Z-force,stress,strain (no axial compression accounted here; can be evaluated separately;
+  usually relatively small)
+* Isotropic material
+    * This method could be extended to handle orthotropic material, with some effort
+* Single material region
+    * This method could be extended to handle multiple regions of isotropic materials
+
+Supports
+* Non-uniform r-grid
+* Arbitrary current density and B-field defined on r-grid
+* Nonzero pressure on inner/outer wall (fluid pressure, bucking load, etc)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import cached_property
+from logging import getLogger
+from pathlib import Path
+from typing import Callable, Literal
+
+import findiff
+import numpy as np
+from numpy.typing import NDArray
+from pydantic import ConfigDict
+from pydantic_numpy.model import NumpyModel
+from pydantic_numpy.typing import NpNDArray  # Array of any type or dimensionality
+from scipy import io, sparse
+from scipy.sparse import csc_matrix as CSC
+from scipy.sparse import csr_matrix as CSR
+from scipy.sparse.linalg import factorized
+
+
+def solenoid_1d_structural_factor(elasticity_modulus: float, poisson_ratio: float) -> float:
+    """Structural factor applied to RHS of solenoid stress solve"""
+    c = (1.0 - poisson_ratio**2) / elasticity_modulus  # [m/N]
+    return c
+
+
+def solenoid_1d_structural_rhs(
+    c: float,
+    j: NDArray | list[float],
+    bz: NDArray | list[float],
+    pi: float = 0.0,
+    po: float = 0.0,
+) -> NDArray:
+    """
+    Right-hand-side for solenoid stress solve,
+    including zero values at the BCs.
+
+    From Iwasa 2e eqn. 3.64a
+
+    Recommend padding the grid with a dummy value at either end
+    to make room for the BCs without losing accounting of nonzero
+    current density at the inner/outer radius.
+
+    Padding for BCs can be done like:
+    `rgrid = np.array([r0 - 1e-6] + rgrid.tolist() + [r1 + 1e-6])`
+
+    Padding region is ultimately treated as structural material,
+    so the padded region should be small to avoid introducing error,
+    but not so small that it causes numerical error in the finite difference scheme.
+
+    Args:
+        c: [m/N] scalar structural factor; see `solenoid_1d_structural_factor()`
+        j: [A/m^2] with shape (n x 1), current density at each point in the r-grid
+        bz: [T] with shape (n x 1), Z-axis B-field at each point in the r-grid
+        pi: [Pa] scalar pressure on inner wall, defined in +r direction
+        po: [Pa] scalar pressure on outer wall, defined in -r direction
+
+    Returns:
+        -c * j * bz, [1/m^2] with shape (n x 1), the right-hand side of the solenoid stress PDE
+    """
+    # Guarantee arrays
+    j = np.array(j)
+    bz = np.array(bz)
+
+    # RHS without BCs
+    rhs = -c * j * bz
+
+    # BC for r-stress at inner and outer radius
+    # is the fluid or mechanical pressure, which is usually going to be set to zero
+    # to represent an unsupported system, but could be set to a nonzero value
+    # to represent a surface load.
+    rhs[0] = -pi  # Sign convention: compression is negative stress
+    rhs[-1] = -po
+
+    return rhs
+
+
+class SolenoidStress1D(NumpyModel):
+    model_config = ConfigDict(validate_assignment=True, frozen=True, extra="forbid")
+
+    rgrid: NpNDArray
+    """[m] 1D grid of r-coordinates"""
+    elasticity_modulus: float
+    """[Pa] diagonal terms in material property matrix"""
+    poisson_ratio: float
+    """[dimensionless] factor determining off-diagonal terms in material property matrix"""
+    order: Literal[2, 4] = 4
+    """Finite-difference stencil polynomial order.
+       Higher order operators produce excessive numerical error under typical use."""
+    direct_inverse: bool = False
+    """Whether to generate fully-dense direct inverse of the system, which
+    can be useful as a linear operator. Alternatively, the system can be solved
+    using an LU solver with reduced memory usage and better numerical conditioning."""
+
+    @cached_property
+    def operators(self) -> SolenoidStress1DOperators:
+        """
+        Linear operators for solving stress and strain in a pancake coil
+        following Iwasa 2e section 3.6.
+        """
+        return solenoid_1d_structural_operators(
+            np.array(self.rgrid), self.elasticity_modulus, self.poisson_ratio, self.order, self.direct_inverse
+        )
+
+    @cached_property
+    def displacement_solver(self) -> Callable[[NDArray], NDArray]:
+        """LU solver for load-displacement relation (A_ub)
+        as an alternative to taking a direct inverse of A_bu"""
+        return factorized(self.operators.a_bu)
+
+
+@dataclass(frozen=True)
+class SolenoidStress1DOperators:
+    """
+    Linear operators for solving stress and strain in a pancake coil
+    following Iwasa 2e section 3.6.
+
+    A_bu, (n x n) sparse operator mapping displacement to the RHS like A @ u_r = -c * j * bz
+    A_ub, (n x n) fully-dense direct inverse of A_bu mapping RHS to displacement
+    A_eu (2n x n), A_eu_radial (n x n), A_eu_hoop (n x n), sparse operators mapping displacement to strain
+        * First entry is combined operator producing both strain components
+        * Second and third entries are split operators, which are equivalent because they are fully decoupled
+    A_se (2n x 2n), sparse operator mapping strain to stress
+    """
+
+    a_bu: CSC
+    """(n x n) sparse operator mapping displacement to the RHS like A @ u_r = -c * j * bz"""
+    a_ub: NDArray | None
+    """(n x n) fully-dense direct inverse of A_bu mapping RHS to displacement.
+        Only generated if `direct_inverse` flag is set."""
+    a_eu: CSR
+    """(2n x n), sparse operator mapping displacement to strain; contains both radial and hoop components"""
+    a_eu_radial: CSR
+    """(n x n), sparse operators mapping displacement to strain; radial component only"""
+    a_eu_hoop: CSR
+    """(n x n), sparse operators mapping displacement to strain; hoop component only"""
+    a_se: CSR
+    """(2n x 2n), sparse operator mapping strain to stress"""
+
+    def write_mat(self, dst: str | Path) -> str:
+        """Write the collection of operators in .mat format.
+
+        Args:
+            dst: Target directory to place the file named "stress_operators.mat"
+
+        Raises:
+            IOError: If the directory does not exist
+        """
+        # Check directory
+        dst = Path(dst).absolute()
+        fpath = dst / "stress_operators.mat"
+        getLogger("cfsem").info(f"Saving stress operator data to {fpath}")
+
+        to_save = {
+            "A_bu": self.a_bu,
+            "A_ub": self.a_ub,
+            "A_eu": self.a_eu,
+            "A_eu_radial": self.a_eu_radial,
+            "A_eu_hoop": self.a_eu_hoop,
+            "A_se": self.a_se,
+        }
+
+        if self.a_ub is None:  # savemat fails on None value
+            to_save.pop("A_ub")
+
+        #    Note this will implicitly convert all CSR matrices to CSC, which is .mat's preferred I/O
+        io.savemat(fpath, to_save)
+
+        return f"{fpath}"
+
+
+def solenoid_1d_structural_operators(
+    rgrid: NDArray | list,
+    elasticity_modulus: float,
+    poisson_ratio: float,
+    order: Literal[2, 4],
+    direct_inverse: bool = False,
+) -> SolenoidStress1DOperators:
+    """
+    Linear operators for solving stress and strain in a pancake coil
+    following Iwasa 2e section 3.6.
+
+    Assumes
+    * Uniform current density within each r-section
+    * Zero R-Z shear (deck-of-cards structure)
+    * Zero Z-force,stress,strain (no axial compression accounted here; can be evaluated separately;
+      usually relatively small)
+    * Isotropic material
+      * This method could be extended to handle orthotropic material, with some effort
+    * Single material region
+      * This method could be extended to handle multiple regions of isotropic materials
+
+    Supports
+    * Non-uniform r-grid
+    * Arbitrary current density and B-field defined on r-grid
+
+    Args:
+        rgrid: [m] with shape (n x 1), Grid of r-coordinates. Must be sorted ascending.
+        elasticity_modulus: [N/m] Material property; Young's modulus
+        poisson_ratio: [dimensionless] Material property; off-axis stress coupling term
+        order: Finite-difference stencil polynomial order
+        direct_inverse: Whether to generate fully-dense direct inverse of the system, which
+                        can be useful as a linear operator.
+                        Alternatively, the system can be solved using an LU solver with
+                        reduced memory usage and better numerical conditioning.
+
+    Returns:
+        object containing linear operators
+    """
+    # Guarantee arrays
+    rgrid = np.array(rgrid)
+    nr = len(rgrid)
+
+    #
+    # Stencils / differential operators
+    #
+
+    # Note these will include the 1/dr and 1/dr^2 scalings,
+    # not just the normalized stencil
+    ddr = findiff.Diff(0, rgrid, acc=order)
+    d2dr2 = ddr**2
+
+    ddr = ddr.matrix((nr,))
+    d2dr2 = d2dr2.matrix((nr,))
+
+    rinv = CSR(np.diag(1.0 / rgrid))
+    rinv2 = CSR(np.diag(1.0 / rgrid**2))
+
+    #
+    # Displacement-load relation
+    #
+
+    # The first and last row of the u-b relation will be modified later
+    # to include the boundary conditions
+    #
+    # Iwasa 2e eqn. 3.64a left hand side
+    #
+    # This one is converted to CSC because, while it's easiest to build it as CSR,
+    # it is more useful for solving a system as CSC
+    a_bu = CSC(d2dr2 + (rinv @ ddr) - rinv2)  # Operator maps displacement TO rhs (-c*j*B)
+
+    # Stress-strain relation components
+    # that are needed for BCs
+    # Iwasa 2e eqns. 3.63g
+    a_stress_strain = np.array(
+        [
+            [1.0 / elasticity_modulus, -poisson_ratio / elasticity_modulus],
+            [-poisson_ratio / elasticity_modulus, 1.0 / elasticity_modulus],
+        ]
+    )
+    a_strain_stress = np.linalg.inv(a_stress_strain)
+    diag_term = a_strain_stress[0, 0]
+    off_diag_term = a_strain_stress[1, 0]
+
+    # We only need the first and last row of this matrix.
+    # Actualizing the whole thing is easy but unnecessary
+    # This is extracted by hand-calc starting from
+    # Iwasa 2e eqns. 3.63a-d
+    bcmat = diag_term * ddr + off_diag_term * rinv
+
+    # Apply BC to displacement operator
+    a_bu[0, :] = bcmat[0, :]
+    a_bu[-1, :] = bcmat[-1, :]
+
+    # Invert A_bu directly to get A_ub
+    # This is fully dense, which may be prohibitive in some situations
+    a_ub = (
+        None if not direct_inverse else np.linalg.inv(a_bu.todense())
+    )  # Operator maps RHS=-c*j*bz to displacement
+
+    #
+    # Strain-displacement operator(s)
+    #
+    # Iwasa 2e eqns. 3.63a-d
+    a_eu_hoop = rinv  # Just the hoop part
+    a_eu_radial = ddr  # Just the radial part
+    # fmt: off
+    a_eu = CSR(sparse.block_array(
+        [[a_eu_radial],
+         [a_eu_hoop]]
+    ))  # Operator for getting strain from displacement
+    # fmt: on
+
+    #
+    # Stress-strain operators
+    #
+    # In this case, we're manually assembling the inverse of the A_es matrix
+    # because we know all the components from handcalc arithmetic
+    eye = sparse.eye(nr, nr)
+    # fmt: off
+    a_se = CSR(sparse.block_array(
+        [[   diag_term * eye, off_diag_term * eye],
+        [off_diag_term * eye, diag_term * eye]]
+    )) # Operator maps strain to stress
+    # fmt: on
+
+    return SolenoidStress1DOperators(a_bu, a_ub, a_eu, a_eu_radial, a_eu_hoop, a_se)

cfsem-2.5.0/cfsem/solenoid_stress/solenoid_handcalc.py

@@ -0,0 +1,91 @@
+"""
+Radial and hoop stress in an infinitely long solenoid under linearly-varying self field.
+The "infinite length" assumption is equivalent to assuming zero R-Z shear ("deck of cards")
+and assuming no B-field in the R-direction (no Z-load or stress).
+
+The linearly varying B-field from inside to outside allows slightly extending this
+to partially account for the finite length of a real solenoid, which produces
+a region of negative Bz near the outer radius (as opposed to the true infinite solenoid,
+for which Bz trends to exactly zero at the outer radius).
+
+Iwasa 2e pg 101 eqns 3.77a,b .
+"""
+
+from numpy.typing import NDArray
+
+
+def s_long_solenoid(
+    r: NDArray,
+    ri: float,
+    ro: float,
+    j: float,
+    bzi: float,
+    bzo: float,
+    poisson_ratio: float,
+) -> tuple[NDArray, NDArray]:
+    """
+    Radial and hoop stress in an infinitely long solenoid under linearly-varying self field.
+    The "infinite length" assumption is equivalent to assuming zero R-Z shear ("deck of cards")
+    and assuming no B-field in the R-direction (no Z-load or stress).
+
+    The linearly varying B-field from inside to outside allows slightly extending this
+    to partially account for the finite length of a real solenoid, which produces
+    a region of negative Bz near the outer radius (as opposed to the true infinite solenoid,
+    for which Bz trends to exactly zero at the outer radius).
+
+    Iwasa 2e pg 101 eqns 3.77a,b .
+
+    Assumes
+    * Infinitely long solenoid (no R-field or Z-stress).
+    * Linear B-field fall-off between inner and outer radius
+      * "Very long" solenoid - allows some negative field at the OD, but always linearly varying
+    * Uniform current density; no bulk regions of non-conducting structure
+    * Radial stress at inner and outer radius is zero (BC due to no support)
+    * Isotropic material
+    * No thermal stress
+
+    Can acommodate a uniform or linearly-varying background field, but not general fields.
+
+    Args:
+        r: [m] (n x 1) array of radius points at which to evaluate the stress
+        ri: [m] inner radius
+        ro: [m] outer radius
+        j: [A/m^2] current density
+        bzi: [T] axial B-field at inner radius
+        bzo: [T] axial B-field at outer radius
+        poisson_ratio: [dimensionless] Material property; off-axis stress coupling term
+
+    Returns:
+        s_radial, s_hoop - each (n x 1) with units of [Pa]
+    """
+
+    # Terms shared between s_radial and s_hoop
+    nu = poisson_ratio
+    rho = r / ri
+    alpha = ro / ri
+    kappa = bzo / bzi
+
+    jbr = j * bzi * ri  # [Pa]
+    term1 = jbr / (alpha - 1.0)  # [Pa]
+    term2 = (2.0 + nu) / 3.0
+    term3 = (3.0 + nu) / 8.0
+    term4 = alpha - kappa
+    term5 = 1.0 - kappa
+
+    # s_radial
+    term6 = ((alpha**2 + alpha + 1.0 - alpha**2 / rho**2) / (alpha + 1.0)) - rho
+    term7 = term3 * term5 * (alpha**2 + 1.0 - alpha**2 / rho**2 - rho**2)
+    s_radial = term1 * (term2 * term4 * term6 - term7)  # [Pa]
+
+    # s_hoop
+    term8 = term2 * (alpha**2 + alpha + 1.0 + alpha**2 / rho**2) / (alpha + 1.0)
+    term9 = rho * (1.0 + 2.0 * nu) / 3.0
+    term10 = term4 * (term8 - term9)
+
+    term11 = term3 * (alpha**2 + 1.0 + alpha**2 / rho**2)
+    term12 = rho**2 * (1.0 + 3.0 * nu) / 8.0
+    term13 = term5 * (term11 - term12)
+
+    s_hoop = term1 * (term10 - term13)  # [Pa]
+
+    return s_radial, s_hoop  # [Pa]

cfsem-2.5.0/cfsem/solenoid_stress/thick_wall_cylinder_handcalc.py

@@ -0,0 +1,69 @@
+"""
+Lamé's Equations - solutions to thick walled cylinder stress distribution for a configuration
+of infinite length, with a fixed pressure boundary condition on the inner and outer radii,
+with constant and isotropic material properties and small displacements.
+"""
+
+from numpy.typing import NDArray
+
+
+def s_hoop_thick_wall_cylinder(
+    r: NDArray, ri: float, ro: float, pin: float, pout: float
+) -> NDArray:
+    """
+    Hoop stress at a location in a thick walled cylinder under pressure load
+    with ends "capped", although the capped constraint does not affect the hoop or radial stress
+    compared to an infinite-length constraint.
+
+    https://www.engineeringtoolbox.com/stress-thick-walled-tube-d_949.html
+    https://www.suncam.com/miva/downloads/docs/303.pdf
+
+    Args:
+        r: [m] radius at which to evaluate
+        ri: [m] inner radius
+        ro: [m] outer radius
+        pin: [Pa] inside pressure
+        pout: [Pa] outside pressure
+
+    Returns:
+        [Pa] hoop stress
+    """
+    # Factors of pi cancel out
+    # fmt: off
+    s_hoop = (
+        (pin * ri ** 2 - pout * ro ** 2) / (ro ** 2 - ri ** 2) -
+        (ri ** 2 * ro ** 2 * (pout - pin) / (r ** 2 * (ro ** 2 - ri ** 2)))
+    )
+    # fmt: on
+
+    return s_hoop  # [Pa] hoop stress
+
+
+def s_radial_thick_wall_cylinder(r: NDArray, ri: float, ro: float, pin: float, pout: float) -> NDArray:
+    """
+    Radial stress at a location in a thick walled cylinder under pressure load
+    with ends "capped", although the capped constraint does not affect the hoop or radial stress
+    compared to an infinite-length constraint.
+
+    https://www.engineeringtoolbox.com/stress-thick-walled-tube-d_949.html
+    https://www.suncam.com/miva/downloads/docs/303.pdf
+
+    Args:
+        r: [m] radius at which to evaluate
+        ri: [m] inner radius
+        ro: [m] outer radius
+        pin: [Pa] inside pressure
+        pout: [Pa] outside pressure
+
+    Returns:
+        [Pa] radial stress
+    """
+    # Factors of pi cancel out
+    # fmt: off
+    s_radial = (
+        ((pin * ri**2 - pout * ro**2) / (ro**2 - ri**2)) + \
+        (ri**2 * ro**2 * (pout - pin) / (r**2 * (ro**2 - ri**2)))
+    )
+    # fmt: on
+
+    return s_radial  # [Pa] radial stress

cfsem-2.5.0/docs/python/solenoid_stress.md

@@ -0,0 +1,5 @@
+# Solenoid Stress & Strain
+
+::: cfsem.solenoid_stress
+    options:
+      show_submodules: true

{cfsem-2.4.3 → cfsem-2.5.0}/examples/helmholtz.py

@@ -1,9 +1,11 @@
 """Calculate the B-field from a Helmholtz coil pair."""
 
 import os
+
 import numpy as np
 from matplotlib import pyplot as plt
-from cfsem import flux_density_circular_filament, MU_0
+
+from cfsem import MU_0, flux_density_circular_filament
 
 coil_radius = 0.2  # [m]
 

{cfsem-2.4.3 → cfsem-2.5.0}/examples/inductance.py

@@ -4,6 +4,7 @@ or as a piecewise-linear helix.
 """
 
 import numpy as np
+
 import cfsem
 
 # Center radius and height, winding pack width and height,

{cfsem-2.4.3 → cfsem-2.5.0}/mkdocs.yml

@@ -27,6 +27,8 @@ nav:
       - "python/vector_potential.md"
       - "python/inductance.md"
       - "python/grad_shafranov.md"
+      - "python/force.md"
+      - "python/solenoid_stress.md"
       - "python/math.md"
       - "python/types.md"
   - "Rust API": "https://docs.rs/cfsem"

{cfsem-2.4.3 → cfsem-2.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cfsem"
-version = "2.4.3"
+version = "2.5.0"
 description = "Quasi-steady electromagnetics including filamentized approximations, Biot-Savart, and Grad-Shafranov."
 authors = [{name = "Commonwealth Fusion Systems", email = "jlogan@cfs.energy"}]
 requires-python = ">=3.9, <3.14"
@@ -16,6 +16,9 @@ classifiers = [
 dependencies = [
     "numpy >= 2",
     "interpn >= 0.2.5",
+    "findiff >= 0.12.1",
+    "pydantic >= 2",
+    "pydantic-numpy >= 6"
 ]
 license = "MIT"
 

{cfsem-2.4.3 → cfsem-2.5.0}/test/test_electromagnetics.py

@@ -516,13 +516,13 @@ def test_wien_against_paper_examples():
     minor_radius_1 = 0.05e-2
     L_ref_1 = 654.40537 * np.pi * 1e-7 * 1e-2  # units: henry
     L_1 = cfsem.self_inductance_circular_ring_wien(major_radius_1, minor_radius_1)
-    assert L_1 == approx(L_ref_1)
+    assert approx(L_ref_1) == L_1
 
     major_radius_2 = 25e-2
     minor_radius_2 = 0.5e-2
     L_ref_2 = 424.1761 * np.pi * 1e-7 * 1e-2  # units: henry
     L_2 = cfsem.self_inductance_circular_ring_wien(major_radius_2, minor_radius_2)
-    assert L_2 == approx(L_ref_2)
+    assert approx(L_ref_2) == L_2
 
 
 @mark.parametrize("r", [0.775, 1.5])

{cfsem-2.4.3 → cfsem-2.5.0}/test/test_funcs.py

@@ -3,10 +3,11 @@
 from typing import Optional
 
 import numpy as np
+from interpn import MultilinearRectilinear
 from numpy.typing import NDArray
 from scipy.constants import mu_0
 from scipy.special import ellipe, ellipk
-from interpn import MultilinearRectilinear
+
 import cfsem