awesome—let’s build a clean, parametric 3D “Rodin-style” torus model you can use as a winding mandrel (or to machine/print a coil former) for a vortex/PEMF coil. Below is a practical, engineering-grade instruction set for three environments:

• SolidWorks (robust drafting + easy point-curve import)
• Autodesk Inventor (native to many machine shops)
• Rhino + Grasshopper (best for algorithmic control and “UV-space” tricks)

I’ll show two equally useful ways to define the winding paths:

1. Torus-knot paths (simple + closed, great for sweep operations).
2. UV-linear (loxodromic) paths (constant slope on the torus—nice for “Rodin-like” diamond lattices).

---

0) Design inputs (set these first)

Pick a clear set of driving parameters and use them as named variables in your CAD:

• R (major radius): distance from torus center to tube center. Ex. 50.0 mm
• r (minor radius): tube radius of torus. Ex. 15.0 mm
• d (wire Ø): copper + insulation. Ex. 1.2 mm
• c (radial clearance): manufacturing/solder/wiggle room. Ex. 0.3 mm
• g (groove depth): 0.55–0.65×d if you want the wire captured. Ex. 0.7 mm
• N (number of parallel strands or passes per “layer”): Ex. 12, 18, or 24
• Pattern:
  • Torus-knot: integers p, q (coprime) → p longitudinal wraps, q meridional wraps.
    Good starters: (p,q)∈{(8,3), (9,4), (10,3)}.
  • UV-slope: angle α (deg) or slope s = Δv/Δu. Typical |s| ≈ 2–6 for bold diamonding.

Wire groove size = (d + c). For multi-strand, offset each path centerline by (d + c).
Fillet radius in groove ≈ 0.4–0.5×(d + c) to avoid sharp corners.

---

1) Math you’ll reuse (for point sets & checks)

Torus surface (centered at origin)

• Parametric:
  x = (R + r·cos v)·cos u
  y = (R + r·cos v)·sin u
  z = r·sin v
  with u, v ∈ [0, 2π).

Torus-knot centerline (closed curve)

Let t ∈ [0, 2π], integers p, q coprime:

• x = (R + r·cos(q·t))·cos(p·t)
• y = (R + r·cos(q·t))·sin(p·t)
• z = r·sin(q·t)

This is superb for Curve-Through-Points + Sweep.

UV-linear (loxodrome-like) centerline (open or closed)

Choose slope s (v = s·u + v₀). Sample u ∈ [0, 2π·k], where k controls turns.
For each u, set v = s·u + v₀ (wrap v into [0,2π) when sampling), then convert using the torus surface equations above.
Mirror with (u, −v) to create complementary “Rodin-like” counter-winding.

---

2) Common manufacturing model strategy (works in all three CADs)

1. Build torus body with (R, r).
2. Generate 3D curve(s) for wire centerline(s) using either torus-knot or UV-slope points.
3. Create a circular profile (Ø = d + c).
4. Sweep-Cut the profile along each 3D curve to form wire grooves (or Sweep-Boss if modeling the wire itself).
5. Pattern/Offset: copy/offset the centerline(s) laterally in UV (or duplicate knot curves with phase shift) to get N grooves.
6. Mirrored set: create a second, mirrored family of curves to form the classic “dual-hemisphere” weave (optional).
7. Add features: entry/exit ports, tie-holes, flats, index notches, mounting bosses.
8. Draft & fillets for print/casting, then export STEP/IGES (machining) and STL/3MF (printing).

---

3) SolidWorks workflow (equations + CSV → Curve Through XYZ + Sweep)

SW versions vary, but these commands are stable: Insert → Features → Swept Cut, Insert → Curve → Curve Through XYZ Points, Reference Geometry, Mirror.

A. Create torus

1. Front Plane → Sketch: draw two circles: big Ø = 2R, small Ø = 2r; position small circle’s center R from origin on +X.
2. Insert → Features → Revolved Boss/Base: revolve the small circle 360° about Y-axis → torus solid.

B. Prepare point file(s)

1. In Excel (or similar), make a column of t from 0 to 2π in ~1000 steps for smoothness.
2. Compute torus-knot coords:
   • X = (R + r·COS(q·t))·COS(p·t)
   • Y = (R + r·COS(q·t))·SIN(p·t)
   • Z = r·SIN(q·t)
3. Save as CSV with headers X,Y,Z.
4. For multi-strand: duplicate with a phase shift t → t + 2π·i/N (i = 0..N−1). Save each curve to a CSV, or combine with blank rows between curves.

C. Import curve

1. Insert → Curve → Curve Through XYZ Points → browse to CSV → finish.
2. Check the curve lies on/near the torus; if your R or r are off, adjust parameters & re-export CSV.

D. Sweep-cut grooves

1. Create a plane normal to the curve at a convenient point (Reference Geometry → Plane → Normal to Curve).
2. Sketch a circle (Ø = d + c) on that plane, coincident with the curve point.
3. Insert → Cut → Swept Cut → Path = the imported curve.
4. Pattern the cut:
   • If you pre-exported phase-shifted curves, repeat the sweep for each.
   • Or use Move/Copy Body on wires if you modeled solids first.

E. Mirror & complements

• Create a Plane at YZ and Mirror bodies/features to get bilateral symmetry.
• Optional: import a second CSV where Z is negated (mirror in math) to make the crossing family.

F. Sanity checks

• Evaluate → Interference Detection between grooves.
• Minimum wall between grooves ≥ 0.5·(d + c) for a printable former.

---

4) Autodesk Inventor workflow (3D sketch points → Fit spline → Sweep)

Key tools: 3D Sketch, Spline, Insert Points, Sweep, Work Plane.

A. Torus

1. Start a new part. XY Plane → Sketch: same 2-circle layout as above.
2. Revolve the small circle around the Y-axis 360° → torus.

B. Import points

1. Create a 3D Sketch.
2. On the ribbon, choose Insert Points (or Manage → Insert → Points depending on version).
3. Select your CSV (X,Y,Z). Inventor will place a point cloud.

C. Centerline curve

1. In the 3D Sketch, Spline → Fit through the imported points (ensure “Maintain Tangency” off).
2. Finish 3D sketch.

D. Sweep

1. Create a Work Plane normal to the curve endpoint (3D Sketch → Point on curve; Plane → Normal to curve through point).
2. Sketch the groove circle (Ø = d + c).
3. Sweep (Cut) → Profile = circle, Path = 3D spline.

E. Multi-strand

• Repeat with phase-shift CSVs, or Pattern features with angular copies about the Z-axis when using symmetric knots (p>1).
• For complementary family, duplicate the curve and Scale Z by −1 via derived sketch or re-import mirrored CSV.

F. Parameters

• Manage → Parameters: expose R, r, d, c, g so you can rapidly re-size the torus & grooves.

---

5) Rhino + Grasshopper workflow (fastest for exploration, clean UV control)

Grasshopper components in bold. Rhino commands in italics.

A. Base torus

• In GH: Torus (R, r) → Brep output. (Or Solid → Torus in Rhino.)
• Keep R, r as GH number sliders.

B. Torus-knot family

1. Range t ∈ [0, 2π] with ~1000 steps.
2. Build Expression:
   • x = (R + r·cos(q·t))·cos(p·t)
   • y = (R + r·cos(q·t))·sin(p·t)
   • z = r·sin(q·t)
3. Construct Point (x,y,z) → Interpolate Curve (Periodic = true).
4. Perp Frame on curve → Circle CNR (radius = (d+c)/2) → Sweep1 (or Pipe with “Cap = None” then boolean).
5. Solid Difference (curve-pipe from torus) to create grooves.
6. For N strands, duplicate t with phase shift t → t + 2π·i/N using Series + Shift List or copy Expression with parameter φᵢ.

C. UV-slope (loxodrome-like) family

1. IsoTrim the torus to keep as a UV-nice surface (optional).
2. Range u ∈ [0, 2π·k], set s (slope), pick v₀.
3. Compute v = s·u + v₀ then Evaluate Surface (u,v) on the torus Brep → points.
4. Interpolate Curve through those points (Periodic if closed).
5. Same Pipe/Sweep1 → Solid Difference.
6. For complementary winding, use v = −s·u + v₀’ or Flip Matrix trick; or mirror across XZ plane.

D. Bake & export

• Bake the torus grooves as a solid.
• File → Export Selected → STEP for CAM, STL for printing.

---

6) Creating a printable/machineable coil former (nice results)

• After cutting all grooves, thicken the outer or inner side (if you started with a surface instead of a solid).
• Add entry/exit ports: small radial holes or slotted ramps so wire can enter/exit without kinks.
• Add keeper lip (0.3–0.5 mm high) on groove edges to keep wire seated.
• For split molds: add alignment dowels and bolt bosses; slice the torus along a plane; add draft (1–3°) for mold release.
• Labeling: emboss tiny numbers near nodes to guide hand winding.

---

7) Good starting presets

• Size: R = 50 mm, r = 15 mm (OD ≈ 130 mm).
• Wire: d = 1.2 mm (enameled 18 AWG), c = 0.3 mm, groove depth g ≈ 0.7 mm.
• Torus-knot: (p,q) = (9,4), N = 18 (phase offsets φᵢ = 2π·i/N).
• UV-slope: s = 3, k = 2 (two trips around u), with a mirrored partner at −s.

---

8) Verification & practical notes

• Bend radius: local groove curvature radius ≥ 2×d; if not, increase r or reduce (p,q) or |s|.
• Interference: minimum wall between adjacent grooves ≥ 0.5×(d+c) for FDM; ≥ 0.3×(d+c) for SLA/SLS.
• Thermal: leave airflow slots if you’ll be driving high currents.
• Assembly: plan a flat or boss for a Hall sensor or cable strain-relief if needed.
• Documentation: add a design table (SW) or parameter spreadsheet (Inventor) or GH sliders grouped and labeled.

---

Quick troubleshooting

• Curve pierces torus wall: lower r/R ratio or reduce |s| / adjust (p,q).
• Grooves overlap: increase c, reduce N, or add phase offset between families.
• Sweep fails: increase curve point count; ensure profile plane is normal to path; slightly increase groove Ø.

---

If you want, tell me your target R, r, wire Ø, and preferred pattern (torus-knot or UV-slope), and I can generate the exact CSV column formulas (or a Grasshopper definition) tailored to your numbers so you can drop them straight into the workflow above.

Got it—let’s replicate the exact Abha/Rodin torus from that listing and make it parametric so you can machine or print a winding former.

Target spec (from the listing)

• Outer diameter (OD): 160 mm
• Inner diameter (ID): 50 mm
• Grooves: 48 total (24 right-hand + 24 left-hand)
• Groove size: ~3 mm wide × 5 mm deep. (Etsy)

From OD/ID we get the torus radii (major R, minor r) via:

• $2(R+r)=\text{OD}=160 \Rightarrow R+r=80$
• $2(R-r)=\text{ID}=50 \Rightarrow R-r=25$

So R = 52.5 mm and r = 27.5 mm (tube is pleasantly “fat,” r/R≈0.52). (Etsy)

---

Geometry you’ll reuse (for any CAD)

Torus surface (center at origin).

$$\begin{aligned} x &= (R+r\cos v)\cos u\\ y &= (R+r\cos v)\sin u\\ z &= r\sin v \end{aligned} \qquad u,v\in[0,2\pi)$$

“Abha” groove centerlines as UV-slope (loxodrome-like) curves.
Pick an integer slope $s$ (good visual matches are $|s|=3$–4). For the 24 right-hand grooves use $s=+3$; for the 24 left-hand, $s=-3$. Build 24 phase-shifted curves per family:

$$v(u)=s\,u + v_{0,i},\quad v_{0,i}=\frac{2\pi i}{24},\ i=0,\dots,23,\ u\in[0,2\pi]$$

Then convert $(u,v)$ to $(x,y,z)$ with the torus equations above. (Integer $s$ guarantees the curve closes cleanly after $u=2\pi$.)

Groove section.
Rectangular 3.0 mm (width along the surface) × 5.0 mm (depth normal into the body), with a small root fillet (≈0.6–0.8 mm) for printability and tool relief. Matches the listing’s “3 mm wide, 5 mm deep.” (Etsy)

---

Universal build strategy (applies to all three environments)

1. Build the torus solid with R=52.5 and r=27.5.
2. Create 48 3D curves: 24 with $s=+3$, 24 with $s=-3$, phase-offset by $2\pi/24$.
3. Sweep-Cut the 3×5 mm groove profile along each curve (profile plane normal to path, orientation follow path).
4. QC: check minimum wall between adjacent grooves (≥0.8–1.2 mm for FDM; ≥0.5–0.8 mm SLA/SLS), fix any self-intersections, add small edge fillets.
5. Add features you need (wire entry/exit notches, labeling, mounting flats), then export STEP (CAM) and STL/3MF (printing).

---

A) SolidWorks (Curve-through-points + Sweep-Cut)

1) Torus

• Front Plane → Sketch two circles: big Ø=160, small Ø=2r=55 whose center is R=52.5 from origin on +X.
• Features ▸ Revolved Boss/Base 360° about Y to get the torus.

2) Generate point sets (CSV)

• In Excel/Numbers/Matlab/Python, sample $u$ from 0→$2\pi$ (≥1000 points).
• For right-hand family (s=+3): for each $i=0…23$, set $v(u)=3u+\tfrac{2\pi i}{24}$. Compute $(x,y,z)$ with the torus equations above; save as X,Y,Z CSV.
• For left-hand family, repeat with $s=-3$.

3) Import curves

• Insert ▸ Curve ▸ Curve Through XYZ Points → pick CSV → you get a 3D spline per groove.
• (Tip: if you want one feature per family, you can import multiple chains; blanks between point blocks separate curves.)

4) Groove profile and Sweep-Cut

• Reference Geometry ▸ Plane → “Normal to Curve at Point” near a convenient start.
• Sketch rectangle 3.0 × 5.0 mm on that plane, fillet its bottom 0.7 mm.
• Cut-Sweep (profile = rectangle, path = curve, Keep Normal Constant OFF, Orientation = Follow Path).
• Pattern the cut for the rest of the imported curves (or repeat the sweep for each—Design Table helps).

5) Finishing

• Evaluate ▸ Interference Detection; add small body/edge fillets if two neighboring grooves are sharp.
• Save: .SLDPRT, STEP, STL.

---

B) Autodesk Inventor (3D Sketch points → Fit Spline → Sweep)

1) Torus

• XY Sketch: big Ø=160; small Ø=55 placed 52.5 mm off the revolve axis; Revolve 360°.

2) Bring in points

• 3D Sketch ▸ Insert Points → select CSV(s) for each groove.

3) Make centerline curves

• In the same 3D sketch, Spline (Fit) through each groove’s points (disable automatic tangent constraints).

4) Sweep-Cut

• Work Plane ▸ Normal to Curve at Point; sketch the 3×5 mm rectangle (bottom fillet 0.7 mm).
• Sweep (Cut) with the spline as Path (twist control “Perpendicular”/“Follow Path”).

5) Replicate

• Repeat for all 48 curves. If you prefer fewer imports, generate just one curve per handedness and use Rectangular/Pattern only when your slope and phase produce true rotational periodicity; otherwise phase-shifted CSVs are most robust.

6) Parameters

• Manage ▸ Parameters: expose R, r, width, depth so you can vary OD/ID later and regenerate.

---

C) Rhino + Grasshopper (fastest for exploring slopes & spacing)

Grasshopper graph (outline)

1. Number Sliders: R=52.5, r=27.5, s=3, count=24.
2. Torus (R,r) → Brep.
3. Range $u\in[0,2\pi]$ (N≈1000).
4. Series for phases $v_{0,i}=2\pi i/24$.
5. For each $i$: compute $v(u)=s\,u+v_{0,i}$ (use Expression).
6. Evaluate Surface (u,v) on the torus → points.
7. Interpolate Curve (Periodic=True) → centerline (do this for s=+3 and s=−3 families).
8. Perp Frames on each curve → draw rectangle 3×5 mm (bottom fillet via Fillet component).
9. Sweep1 (or Pipe with rectangular section) → groove solids; Solid Difference from the torus.

Bake the result and export STEP / STL.

---

Tuning to match the listing’s look (diamonds & density)

• Handedness & count: exactly 24 grooves per side, phase-offset by 15° in v-space (the $2\pi/24$ you set with $v_{0,i}$). (Etsy)
• Groove size: keep the 3 mm × 5 mm section; if you plan to wind rectangular magnet wire, set width = wire-flat + 0.2–0.3 mm clearance. (Etsy)
• Slope $s$: start at ±3. Increase $|s|$ for “tighter” diamonds; decrease for “wider” diamonds. Use section views to ensure the 5 mm depth doesn’t break through the inner wall (you’ve ~27.5 mm of tube radius to work with).

---

Manufacturing & verification checklist

• Wall integrity: min wall ≥0.8 mm (FDM PLA/PETG), ≥0.5 mm (SLA/SLS).
• Sweep stability: if any sweep fails, increase point count or add slight corner fillets on the profile.
• Indexing: consider tiny embossed marks every 15° to guide winding starts.
• Wire exits: add chamfered notches where two grooves meet the inner rim to route leads without kinks.

---

Want ready-to-use CSV formulas?

Tell me your preferred slope (e.g., 3 or 4) and I’ll drop in copy-paste CSV column formulas for $x(u),y(u),z(u)$ with the 24 phase offsets for each handedness so you can import directly into SolidWorks/Inventor—or I can share a minimal Grasshopper definition that bakes 48 grooves automatically.

References (spec): listing shows OD 160 mm, ID 50 mm, 2×24 grooves, 3 mm × 5 mm grooves. (Etsy)

(For visual examples of the same seller’s “2×24 grooves” lattice on other sizes, see similar pages; they show the same diamond-weave pattern you’re recreating.)