step2torque 0.1.0__tar.gz

step2torque-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 step2torque contributors
+
+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.
+

step2torque-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: step2torque
+Version: 0.1.0
+Summary: STEP assemblies to nonlinear 3D motor torque, from Python.
+License-Expression: MIT
+Project-URL: Repository, https://github.com/qwertpas/step2torque
+Project-URL: Viewer, https://qwertpas.github.io/step2torque/
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ngsolve>=6.2.2608
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.12
+Requires-Dist: psutil>=5.9
+Requires-Dist: matplotlib>=3.8
+Provides-Extra: cuda
+Requires-Dist: nvmath-python[cu12]; extra == "cuda"
+Requires-Dist: nvidia-cudss-cu12; extra == "cuda"
+Requires-Dist: cupy-cuda12x; extra == "cuda"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: build; extra == "test"
+Requires-Dist: ruff; extra == "test"
+Dynamic: license-file
+
+# step2torque
+
+GPU-accelerated nonlinear 3D FEM solver to get motor torque from a STEP assembly. Simple python interface makes it easy to automate evaluation of your custom motors with arbitrary geometry.
+
+[Open the browser viewer](https://qwertpas.github.io/step2torque/)
+
+| Model | Flux density |
+|---|---|
+| <img src="examples/simple/model-3d.png" height="300" alt="Motor CAD view"> | <img src="examples/simple/animation.gif" height="300" alt="Motor flux density animation"> |
+
+Install:
+```sh
+python3 -m pip install step2torque
+```
+
+Solve using your own .step file:
+```python
+from step2torque import Motor
+
+motor = Motor("motor.step")
+print(motor.components)  # CAD component names
+motor.components["stator"].set_material("1J22")
+motor.components["coil"].make_coil(phase=1, turns=72, direction="+z")
+motor.components["magnet"].make_magnet(direction="radial", br=1.2)
+
+sol = motor.solve(power=5.5)  # returns immediately; optimizes currents
+print(sol.status, sol.progress)
+sol.wait()                  # optional blocking wait
+print(sol.torque, sol.currents)  # N·m, instantaneous phase A
+print(sol.flux_density([[0, 0, 0]]))  # B in tesla, points in CAD mm
+```
+
+Render and share the solved field:
+
+```python
+from step2torque import Plane
+sol.render_image("field.png", plane=Plane.axial(z=0))
+sol.render_html("motor.html")
+sol.export("motor.s2t")
+```
+
+Open the HTML directly, or load the `.s2t` file in the browser viewer.
+
+---
+
+### Specifying parameters
+- Coils are circular or rectangular annuli; direction is their right-hand axis. Specify turns or resistance; the other parameter is calculated using CAD dimensions, 60% copper fill and 20°C.
+- Multiphase currents sum to zero by default; `balanced=False` permits independent phase drives. Coils sharing a phase are in series; resistance is per coil.
+- Magnets accept a global vector, `"radial"`, or `"-radial"`. For a multipole ring, use `make_magnet(direction="radial", poles=20)`; `offset=5` shifts its pole pattern by 5 mechanical degrees.
+- Rotor-named components and magnets can be rotated. `Motor(..., axis="+z", center=(0,0,0))` changes the shaft axis and center in mm.
+- `motor.solve(angle=10, current={1: 2.0})` rotates moving parts 10 mechanical degrees from the STEP and uses fixed current. Use `current={}` to get cogging (torque at zero current).
+- Separate touching iron parts use a 10 µm surface contact. `Motor(..., contact_gap=0.01)` sets this gap in mm; use zero for perfect magnetic contact.
+- Other components default to steel.
+- Before solving, you may use `motor.render_image("setup.png")`, `motor.render_html("setup.html")` or `motor.export("setup.s2t")` to check the geometry, phase labels and winding direction. Preview currents default to 1 A per phase; pass `current={1: 2.0}` and `angle=10` to set their initial values.
+
+
+GPU acceleration is included. `python3 -m pip install 'step2torque[cuda]'` enables NVIDIA
+cuDSS; `device="auto"` selects an available device. Optional solve arguments:
+`threads=8`, `mesh_size=0.6` (surface mm).
+
+[Examples, benchmarks and commercial case studies](examples/README.md)
+

step2torque-0.1.0/README.md

@@ -0,0 +1,62 @@
+# step2torque
+
+GPU-accelerated nonlinear 3D FEM solver to get motor torque from a STEP assembly. Simple python interface makes it easy to automate evaluation of your custom motors with arbitrary geometry.
+
+[Open the browser viewer](https://qwertpas.github.io/step2torque/)
+
+| Model | Flux density |
+|---|---|
+| <img src="examples/simple/model-3d.png" height="300" alt="Motor CAD view"> | <img src="examples/simple/animation.gif" height="300" alt="Motor flux density animation"> |
+
+Install:
+```sh
+python3 -m pip install step2torque
+```
+
+Solve using your own .step file:
+```python
+from step2torque import Motor
+
+motor = Motor("motor.step")
+print(motor.components)  # CAD component names
+motor.components["stator"].set_material("1J22")
+motor.components["coil"].make_coil(phase=1, turns=72, direction="+z")
+motor.components["magnet"].make_magnet(direction="radial", br=1.2)
+
+sol = motor.solve(power=5.5)  # returns immediately; optimizes currents
+print(sol.status, sol.progress)
+sol.wait()                  # optional blocking wait
+print(sol.torque, sol.currents)  # N·m, instantaneous phase A
+print(sol.flux_density([[0, 0, 0]]))  # B in tesla, points in CAD mm
+```
+
+Render and share the solved field:
+
+```python
+from step2torque import Plane
+sol.render_image("field.png", plane=Plane.axial(z=0))
+sol.render_html("motor.html")
+sol.export("motor.s2t")
+```
+
+Open the HTML directly, or load the `.s2t` file in the browser viewer.
+
+---
+
+### Specifying parameters
+- Coils are circular or rectangular annuli; direction is their right-hand axis. Specify turns or resistance; the other parameter is calculated using CAD dimensions, 60% copper fill and 20°C.
+- Multiphase currents sum to zero by default; `balanced=False` permits independent phase drives. Coils sharing a phase are in series; resistance is per coil.
+- Magnets accept a global vector, `"radial"`, or `"-radial"`. For a multipole ring, use `make_magnet(direction="radial", poles=20)`; `offset=5` shifts its pole pattern by 5 mechanical degrees.
+- Rotor-named components and magnets can be rotated. `Motor(..., axis="+z", center=(0,0,0))` changes the shaft axis and center in mm.
+- `motor.solve(angle=10, current={1: 2.0})` rotates moving parts 10 mechanical degrees from the STEP and uses fixed current. Use `current={}` to get cogging (torque at zero current).
+- Separate touching iron parts use a 10 µm surface contact. `Motor(..., contact_gap=0.01)` sets this gap in mm; use zero for perfect magnetic contact.
+- Other components default to steel.
+- Before solving, you may use `motor.render_image("setup.png")`, `motor.render_html("setup.html")` or `motor.export("setup.s2t")` to check the geometry, phase labels and winding direction. Preview currents default to 1 A per phase; pass `current={1: 2.0}` and `angle=10` to set their initial values.
+
+
+GPU acceleration is included. `python3 -m pip install 'step2torque[cuda]'` enables NVIDIA
+cuDSS; `device="auto"` selects an available device. Optional solve arguments:
+`threads=8`, `mesh_size=0.6` (surface mm).
+
+[Examples, benchmarks and commercial case studies](examples/README.md)
+

step2torque-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools", "pybind11"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "step2torque"
+version = "0.1.0"
+description = "STEP assemblies to nonlinear 3D motor torque, from Python."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = ["ngsolve>=6.2.2608", "numpy>=1.26", "scipy>=1.12", "psutil>=5.9", "matplotlib>=3.8"]
+
+[project.optional-dependencies]
+cuda = ["nvmath-python[cu12]", "nvidia-cudss-cu12", "cupy-cuda12x"]
+test = ["pytest", "build", "ruff"]
+
+[project.urls]
+Repository = "https://github.com/qwertpas/step2torque"
+Viewer = "https://qwertpas.github.io/step2torque/"
+
+[project.scripts]
+step2torque-view = "step2torque.visualization.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+step2torque = ["materials/*.csv", "materials/*.json", "*.cpp", "*.hpp"]
+"step2torque.visualization" = ["*.html", "*.js"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-m 'not solver'"
+markers = ["solver: opt-in physical solver checks; run explicitly with -m solver"]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F"]
+

step2torque-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

step2torque-0.1.0/setup.py

@@ -0,0 +1,32 @@
+import sys
+import hashlib
+from pathlib import Path
+
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+from setuptools import setup
+
+
+class Build(build_ext):
+    def run(self):
+        super().run()
+        binary = Path(self.get_ext_fullpath("step2torque._assembly"))
+        binary.with_name("_assembly_version.py").write_text(
+            "SHA256 = " + repr(hashlib.sha256(binary.read_bytes()).hexdigest()) + "\n"
+        )
+
+
+threads = [] if sys.platform == "win32" else ["-pthread"]
+optimize = ["/O2"] if sys.platform == "win32" else ["-O3"]
+setup(
+    ext_modules=[
+        Pybind11Extension(
+            "step2torque._assembly",
+            ["src/step2torque/_assembly.cpp"],
+            cxx_std=17,
+            define_macros=[("MOTOR_THREADS", "1")],
+            extra_compile_args=threads + optimize,
+            extra_link_args=threads,
+        )
+    ],
+    cmdclass={"build_ext": Build},
+)

step2torque-0.1.0/src/step2torque/__init__.py

@@ -0,0 +1,16 @@
+"""Load a STEP, configure its components, and solve without blocking.
+
+motor = Motor("motor.step")
+motor.components["coil"].make_coil(phase=1, turns=72, direction="+z")
+motor.components["magnet"].make_magnet(direction="radial")
+solution = motor.solve(current="optimized", power=5.5)
+solution.wait()
+print(solution.torque)  # N m
+"""
+
+from .model import Motor
+from .solution import Solution, solve_position
+from .visualization import Plane, Viewer
+
+__all__ = ["Motor", "Solution", "solve_position", "Plane", "Viewer"]
+__version__ = "0.1.0"

step2torque-0.1.0/src/step2torque/_assembly.cpp

@@ -0,0 +1,161 @@
+// Same affine P2, degree-6 iron quadrature and B(H) energy as _field.py.
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include "_parallel.hpp"
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <stdexcept>
+namespace py = pybind11;
+using Real = py::array_t<double, py::array::c_style>;
+using Int = py::array_t<int, py::array::c_style | py::array::forcecast>;
+using Index = py::array_t<int64_t, py::array::c_style | py::array::forcecast>;
+struct Curve {
+    std::vector<double> h,b,slope,area;
+    std::array<double,3> evaluate(double value) const {
+        int i=std::upper_bound(h.begin(),h.end(),value)-h.begin()-1;
+        i=std::max(0,std::min(i,int(h.size())-2));
+        double t=value-h[i];
+        return {b[i]+t*slope[i],slope[i],area[i]+t*(b[i]+.5*t*slope[i])};
+    }
+};
+class Assembly {
+    int n,ne,nq;
+    int64_t nnz;
+    std::vector<int64_t> ptr,entries,cell_ptr,cell_entries;
+    std::vector<int> col,dofs,curve;
+    std::vector<double> inverse,volume,reference,weights,points,source;
+    std::vector<double> local_matrix,local_load,local_energy;
+    std::vector<Curve> curves;
+    Parallel pool;
+    const double *potential=nullptr;
+    double *matrix=nullptr,*residual=nullptr;
+    double factor=1,floor=.1;
+public:
+    Assembly(Index pointers,Int columns,Int indices,Int labels,Real jac,
+             Real volumes,Real shapes,Real quadrature,Real locations,
+             py::list laws,int threads)
+      : n(pointers.size()-1),ne(labels.size()),nq(quadrature.size()),nnz(columns.size()),
+        ptr(pointers.data(),pointers.data()+pointers.size()),
+        col(columns.data(),columns.data()+columns.size()),
+        dofs(indices.data(),indices.data()+indices.size()),
+        curve(labels.data(),labels.data()+labels.size()),
+        inverse(jac.data(),jac.data()+jac.size()),
+        volume(volumes.data(),volumes.data()+volumes.size()),
+        reference(shapes.data(),shapes.data()+shapes.size()),
+        weights(quadrature.data(),quadrature.data()+quadrature.size()),
+        points(locations.data(),locations.data()+locations.size()),
+        source(size_t(ne)*12),local_matrix(size_t(ne)*55),local_load(size_t(ne)*10),
+        local_energy(ne),pool(threads) {
+        if(indices.size()!=int64_t(ne)*10 || shapes.size()!=nq*30 || jac.size()!=int64_t(ne)*9)
+            throw std::runtime_error("Compiled assembly requires the affine P2 tetrahedron map");
+        for(auto record:laws) {
+            py::tuple pair=py::cast<py::tuple>(record);
+            Real h=py::cast<Real>(pair[0]),b=py::cast<Real>(pair[1]);
+            Curve c;
+            c.h.assign(h.data(),h.data()+h.size());c.b.assign(b.data(),b.data()+b.size());
+            c.slope.resize(h.size()-1);c.area.assign(h.size(),0);
+            for(int i=0;i<h.size()-1;++i) {
+                c.slope[i]=(c.b[i+1]-c.b[i])/(c.h[i+1]-c.h[i]);
+                c.area[i+1]=c.area[i]+.5*(c.b[i]+c.b[i+1])*(c.h[i+1]-c.h[i]);
+            }
+            curves.push_back(std::move(c));
+        }
+        entries.resize(size_t(ne)*100);cell_ptr.assign(n+1,0);cell_entries.resize(size_t(ne)*10);
+        for(int row:dofs) {
+            if(row<0 || row>=n)throw std::runtime_error("Invalid P2 degree of freedom");
+            ++cell_ptr[row+1];
+        }
+        for(int i=1;i<=n;++i)cell_ptr[i]+=cell_ptr[i-1];
+        auto cursor=cell_ptr;
+        for(int64_t i=0;i<int64_t(ne)*10;++i)cell_entries[cursor[dofs[i]]++]=i;
+        for(int e=0;e<ne;++e)for(int i=0;i<10;++i)for(int j=0;j<10;++j) {
+            int row=dofs[e*10+i],column=dofs[e*10+j];
+            auto it=std::lower_bound(col.begin()+ptr[row],col.begin()+ptr[row+1],column);
+            if(it==col.begin()+ptr[row+1] || *it!=column)
+                throw std::runtime_error("Tangent graph differs from finite element map");
+            entries[int64_t(e)*100+i*10+j]=it-col.begin();
+        }
+    }
+    void set_source(Real values) {
+        if(values.size()!=int64_t(ne)*12)throw std::runtime_error("Winding source differs from mesh");
+        std::copy(values.data(),values.data()+values.size(),source.begin());
+    }
+    void assemble(Real phi,double scale,double lower,Real values,Real load) {
+        potential=phi.data();factor=scale;floor=lower;
+        if(phi.size()!=n || values.size()!=nnz || load.size()!=n)
+            throw std::runtime_error("Tangent arrays differ from finite element map");
+        matrix=values.mutable_data();residual=load.mutable_data();
+        py::gil_scoped_release release;
+        integrate(true);
+    }
+    double energy(Real phi,double scale) {
+        potential=phi.data();factor=scale;
+        py::gil_scoped_release release;
+        return integrate(false);
+    }
+private:
+    double integrate(bool assemble) {
+        if(assemble) {std::fill(matrix,matrix+nnz,0);std::fill(residual,residual+n,0);}
+        pool.run(ne,[&](int begin,int end,int){for(int e=begin;e<end;++e) {
+            const double *jac=inverse.data()+9*e,*hs=source.data()+12*e;
+            const int *ids=dofs.data()+10*e;
+            const Curve &law=curves[curve[e]];
+            double local[55]={},load[10]={},cell_energy=0;
+            double offset=law.evaluate(.0001)[2];
+            for(int q=0;q<nq;++q) {
+                const double *ref=reference.data()+30*q,*point=points.data()+3*q;
+                double gradient[10][3],h[3],s[3];
+                for(int c=0;c<3;++c) {
+                    s[c]=factor*(hs[c]+point[0]*(hs[3+c]-hs[c])+point[1]*(hs[6+c]-hs[c])+point[2]*(hs[9+c]-hs[c]));
+                    h[c]=s[c];
+                }
+                for(int i=0;i<10;++i) for(int c=0;c<3;++c) {
+                    gradient[i][c]=ref[3*i]*jac[c]+ref[3*i+1]*jac[3+c]+ref[3*i+2]*jac[6+c];
+                    h[c]-=potential[ids[i]]*gradient[i][c];
+                }
+                double norm2=h[0]*h[0]+h[1]*h[1]+h[2]*h[2]+1e-8;
+                double hn=std::sqrt(norm2),w=volume[e]*weights[q];
+                auto bh=law.evaluate(hn);
+                constexpr double mu0=1.2566370614359173e-6;
+                cell_energy+=w*(bh[2]-offset-.5*mu0*(s[0]*s[0]+s[1]*s[1]+s[2]*s[2]));
+                if(!assemble) continue;
+                double secant=bh[0]/hn;
+                double anisotropic=(std::max(bh[1],floor*secant)-secant)/norm2;
+                double hg[10];
+                for(int i=0;i<10;++i) {
+                    hg[i]=h[0]*gradient[i][0]+h[1]*gradient[i][1]+h[2]*gradient[i][2];
+                    load[i]+=w*secant*hg[i];
+                }
+                for(int i=0;i<10;++i) for(int j=0;j<=i;++j) {
+                    double gram=gradient[i][0]*gradient[j][0]+gradient[i][1]*gradient[j][1]+gradient[i][2]*gradient[j][2];
+                    local[i*(i+1)/2+j]+=w*(secant*gram+anisotropic*hg[i]*hg[j]);
+                }
+            }
+            local_energy[e]=cell_energy;
+            if(assemble) {
+                std::copy(local,local+55,local_matrix.begin()+e*55);
+                std::copy(load,load+10,local_load.begin()+e*10);
+            }
+        }});
+        if(assemble)pool.run(n,[&](int begin,int end,int){for(int row=begin;row<end;++row) {
+            for(int64_t k=cell_ptr[row];k<cell_ptr[row+1];++k) {
+                int64_t entry=cell_entries[k];int e=entry/10,i=entry%10;
+                residual[row]+=local_load[entry];
+                for(int j=0;j<10;++j) {
+                    int a=std::max(i,j),b=std::min(i,j);
+                    matrix[entries[int64_t(e)*100+i*10+j]]+=local_matrix[e*55+a*(a+1)/2+b];
+                }
+            }
+        }});
+        double energy=0;for(double value:local_energy)energy+=value;
+        return energy;
+    }
+};
+PYBIND11_MODULE(_assembly,m) {
+    py::class_<Assembly>(m,"Assembly")
+        .def(py::init<Index,Int,Int,Int,Real,Real,Real,Real,Real,py::list,int>())
+        .def("set_source",&Assembly::set_source)
+        .def("assemble",&Assembly::assemble)
+        .def("energy",&Assembly::energy);
+}