kindred/gears
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

update notebook

Browse Source
This commit is contained in:
looooo
2024-01-05 18:14:10 +01:00
parent 2136e1b4cf
commit 1c53d09c28
2 changed files with 281 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

379
examples/worm_cutting_tool/cutting_tool_worm_assembly.ipynb
View File

@@ -14,68 +14,24 @@
},
{
"cell_type": "code",
"execution_count": 5,
"execution_count": 1,
"id": "7eacf041-aa83-49e2-9cbe-066f177197f6",
"metadata": {},
"outputs": [],
"source": [
"import sympy as sp\n",
"import numpy as np"
"import sympy as sym\n",
"import numpy as np\n",
"from pygears.transformation import symbolic_transformation, numeric_transformation"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "980417d0-c79d-4501-a7cc-9725b3bbea83",
"metadata": {},
"outputs": [],
"source": [
"def symbolic_transformation(angle, axis, translation=np.array([0., 0., 0.])):\n",
" \"\"\"\n",
" see http://en.wikipedia.org/wiki/SO%284%29#The_Euler.E2.80.93Rodrigues_formula_for_3D_rotations\n",
" sympy enabled transformation\n",
" angle: angle of rotation\n",
" axis: the axis of the rotation\n",
" translation: translation of transformation\n",
" \"\"\"\n",
" assert len(axis) == 3\n",
" a = sp.cos(angle / 2)\n",
" axis_normalized = axis / sp.sqrt(axis.dot(axis))\n",
" (b, c, d) = -axis_normalized * sp.sin(angle / 2)\n",
" mat = sp.Matrix(\n",
" [\n",
" [\n",
" a**2 + b**2 - c**2 - d**2,\n",
" 2 * (b * c - a * d),\n",
" 2 * (b * d + a * c),\n",
" translation[0],\n",
" ],\n",
" [\n",
" 2 * (b * c + a * d),\n",
" a**2 + c**2 - b**2 - d**2,\n",
" 2 * (c * d - a * b),\n",
" translation[1],\n",
" ],\n",
" [\n",
" 2 * (b * d - a * c),\n",
" 2 * (c * d + a * b),\n",
" a**2 + d**2 - b**2 - c**2,\n",
" translation[2],\n",
" ],\n",
" [0.0, 0.0, 0.0, 1.0],\n",
" ]\n",
" )\n",
" return sp.simplify(mat)\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"execution_count": 5,
"id": "5852aa56-e66b-4f3c-a50d-0cb4cb21abd2",
"metadata": {},
"outputs": [],
"source": [
"t = sp.Symbol(\"t\")\n",
"t = sym.Symbol(\"t\")\n",
"T1 = symbolic_transformation(np.pi / 2.,\n",
" np.array([1., 0., 0.]),\n",
" np.array([12.5,0., 1.15]))\n",
@@ -86,12 +42,12 @@
" np.array([1., 0., 0.]),\n",
" np.array([0., 0., t]))\n",
"\n",
"T = sp.nsimplify(T2.inv() @ T1.inv() @ T3, tolerance=10e-16)"
"T = sym.nsimplify(T2.inv() @ T1.inv() @ T3, tolerance=10e-16)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"execution_count": 7,
"id": "7c9837b8-caf7-4447-bf0d-eba9085197a5",
"metadata": {},
"outputs": [
@@ -104,14 +60,14 @@
" [ 0. , 0. , 0. , 0. ]])"
]
},
"execution_count": 8,
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"T_fn = sp.lambdify(t, T)\n",
"dT_fn = sp.lambdify(t, T.diff(t))\n",
"T_fn = sym.lambdify(t, T)\n",
"dT_fn = sym.lambdify(t, T.diff(t))\n",
"dT_fn(0.)"
]
},
@@ -196,19 +152,24 @@
},
{
"cell_type": "code",
"execution_count": 15,
"execution_count": 9,
"id": "cfd8026b-5a84-4882-a1de-63580776a579",
"metadata": {},
"outputs": [],
"source": [
"import sympy as sp\n",
"t, x, z, m = sp.symbols([\"t\", \"x\", \"z\", \"m\"], real=True)\n",
"s, alpha, n_t, y = sp.symbols([\"s\", \"alpha\", \"n_t\", \"y\"], real=True, positiv=True)"
"import sympy as sym\n",
"import numpy as np\n",
"import scipy as sp\n",
"\n",
"from pygears.transformation import symbolic_transformation, numeric_transformation\n",
"\n",
"t, x, z, m = sym.symbols([\"t\", \"x\", \"z\", \"m\"], real=True)\n",
"s, alpha, n_t, y = sym.symbols([\"s\", \"alpha\", \"n_t\", \"y\"], real=True, positiv=True)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"execution_count": 10,
"id": "65bb90d7-0f5b-410e-9a3a-0f9953a4d846",
"metadata": {},
"outputs": [
@@ -225,19 +186,19 @@
"[ 0, 0, 0, 1.0]])"
]
},
"execution_count": 16,
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"T_spiral = symbolic_transformation(t * 2 * sp.pi, np.array([0, 0, 1]), np.array([0, 0, m * sp.pi * n_t * t ]))\n",
"T_spiral = symbolic_transformation(t * 2 * sym.pi, np.array([0, 0, 1]), np.array([0, 0, m * sym.pi * n_t * t ]))\n",
"T_spiral"
]
},
{
"cell_type": "code",
"execution_count": 17,
"execution_count": 11,
"id": "0f305b8b-0fb5-4b71-80b6-9a2b43b59e26",
"metadata": {},
"outputs": [
@@ -254,19 +215,19 @@
"[ 1]])"
]
},
"execution_count": 17,
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"l = sp.Matrix([0, s * sp.cos(alpha), s * sp.sin(alpha), 1])\n",
"l = sym.Matrix([0, s * sym.cos(alpha), s * sym.sin(alpha), 1])\n",
"l"
]
},
{
"cell_type": "code",
"execution_count": 18,
"execution_count": 12,
"id": "da3c8575-99ad-4258-8734-c165ea65b014",
"metadata": {},
"outputs": [
@@ -283,7 +244,7 @@
"[ 1.0]])"
]
},
"execution_count": 18,
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
@@ -295,7 +256,7 @@
},
{
"cell_type": "code",
"execution_count": 19,
"execution_count": 13,
"id": "e47eb83b-6e89-4246-a82a-bd5629aedc2a",
"metadata": {},
"outputs": [
@@ -308,19 +269,19 @@
"asin(x/(s*cos(alpha)))/(2*pi)"
]
},
"execution_count": 19,
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x_cross_section = sp.simplify(sp.solve(spiral[0] - x, t)[1])\n",
"x_cross_section = sym.simplify(sym.solve(spiral[0] - x, t)[1])\n",
"x_cross_section # parameter s"
]
},
{
"cell_type": "code",
"execution_count": 20,
"execution_count": 14,
"id": "c2954b39-eea0-4e27-987f-07a5d0dedaad",
"metadata": {},
"outputs": [
@@ -337,19 +298,19 @@
"[ 1.0]])"
]
},
"execution_count": 20,
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"spiral_x = sp.simplify(spiral.subs({t: x_cross_section}))\n",
"spiral_x = sym.simplify(spiral.subs({t: x_cross_section}))\n",
"spiral_x"
]
},
{
"cell_type": "code",
"execution_count": 21,
"execution_count": 15,
"id": "268c6302-4e7d-45e0-be28-1b64cf8b766e",
"metadata": {},
"outputs": [
@@ -362,65 +323,285 @@
"sqrt(x**2 + y**2)/cos(alpha)"
]
},
"execution_count": 21,
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y_cross_section = sp.simplify(sp.solve(spiral_x[1]- y, s)[0])\n",
"y_cross_section = sym.simplify(sym.solve(spiral_x[1]- y, s)[0])\n",
"y_cross_section"
]
},
{
"cell_type": "code",
"execution_count": 22,
"execution_count": 16,
"id": "7284bd6a-b47b-483c-8e9f-79fcaecce5e3",
"metadata": {},
"outputs": [
{
"data": {
"text/latex": [
"$\\displaystyle \\left[\\begin{matrix}x\\\\\\left|{y}\\right|\\\\\\frac{m n_{t} \\operatorname{asin}{\\left(\\frac{x}{\\sqrt{x^{2} + y^{2}}} \\right)}}{2} + \\sqrt{x^{2} + y^{2}} \\tan{\\left(\\alpha \\right)}\\\\1.0\\end{matrix}\\right]$"
"$\\displaystyle \\left[\\begin{matrix}x\\\\y\\\\\\frac{m n_{t} \\operatorname{asin}{\\left(\\frac{x}{r{\\left(x,y \\right)}} \\right)}}{2} + r{\\left(x,y \\right)} \\tan{\\left(\\alpha \\right)}\\\\1.0\\end{matrix}\\right]$"
],
"text/plain": [
"Matrix([\n",
"[ x],\n",
"[ Abs(y)],\n",
"[m*n_t*asin(x/sqrt(x**2 + y**2))/2 + sqrt(x**2 + y**2)*tan(alpha)],\n",
"[ 1.0]])"
"[ x],\n",
"[ y],\n",
"[m*n_t*asin(x/r(x, y))/2 + r(x, y)*tan(alpha)],\n",
"[ 1.0]])"
]
},
"execution_count": 22,
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"spiral_xy = sp.simplify(spiral_x.subs({s: y_cross_section}))\n",
"f_r = sym.Function(\"r\")(x, y)\n",
"spiral_xy = sym.simplify(spiral_x.subs({s: y_cross_section}))\n",
"spiral_xy = spiral_xy.subs({sym.Abs(y): y, sym.sqrt(x**2 + y**2): f_r})\n",
"spiral_xy"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "e7b9f7cc-59f0-4dc6-922c-c94a753c0fd5",
"metadata": {},
"outputs": [
{
"data": {
"text/latex": [
"$\\displaystyle z{\\left(x,y \\right)}$"
],
"text/plain": [
"z(x, y)"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"z = sym.Function(\"z\")(x, y)\n",
"z"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "080e1845-8ff4-493e-aa28-5b677bfa3cb4",
"metadata": {},
"outputs": [
{
"data": {
"text/latex": [
"$\\displaystyle \\frac{y - y_{p} + z{\\left(x,y \\right)} \\frac{\\partial}{\\partial y} z{\\left(x,y \\right)}}{\\sqrt{\\left(y - y_{p}\\right)^{2} + z^{2}{\\left(x,y \\right)}}}$"
],
"text/plain": [
"(y - y_p + z(x, y)*Derivative(z(x, y), y))/sqrt((y - y_p)**2 + z(x, y)**2)"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y_p =sym.Symbol(\"y_p\")\n",
"dist_p = sym.sqrt(z**2 + (y - y_p)**2)\n",
"dist_p.diff(y)"
]
},
{
"cell_type": "markdown",
"id": "d9559950-1520-439c-8e7a-35b4006f104a",
"metadata": {},
"source": [
"## for x = 0, for a first guess of t"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "0811a6d6-4544-4a99-b4bd-ba5cf6b9027e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-2.605082438917929\n",
"-2.5926567550137163\n",
"-2.576276171400715\n",
"-2.5572968584132614\n",
"-2.5371037205738425\n",
"-2.516988590529518\n",
"-2.497957291921094\n",
"-2.4810015545771567\n",
"-2.4665124345839313\n",
"-2.455011136367867\n",
"-2.4464950349176995\n",
"-2.4409613820509275\n",
"-2.438356798763718\n",
"-2.438428922923462\n",
"-2.4408671029182987\n",
"-2.445442245573777\n",
"-2.4521135558911062\n",
"-2.460220787391342\n",
"-2.469626739199975\n",
"-2.4799773695959573\n"
]
},
{
"data": {
"text/plain": [
"<Part::PartFeature>"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import scipy as sp\n",
"import numpy as np\n",
"from freecad import part\n",
"from freecad import app\n",
"from pygears.transformation import numeric_transformation\n",
"\n",
"debug = False\n",
"def compute():\n",
" module = 1.\n",
" num_threads = 3\n",
" alpha = np.deg2rad(20.)\n",
" x = 0.\n",
" r_w = 7.5\n",
" y_p = 5\n",
" r_thales = r_w / 2.\n",
" y_thales = y_p + r_thales\n",
" height = 5.\n",
" \n",
" def length(y):\n",
" return (x**2 + y**2)**(0.5)\n",
" \n",
" def dlength_dy(y):\n",
" return y / length(y)\n",
" \n",
" def z(y, t):\n",
" r = length(y)\n",
" return module * num_threads * np.arcsin(x / r) / 2 + r * np.tan(alpha) + t\n",
" # return r * np.tan(alpha) + t\n",
" \n",
" def dz_dy(y):\n",
" r = length(y)\n",
" return -module * num_threads * x * dlength_dy(y) / \\\n",
" (2 * np.sqrt(1 - x ** 2 / r ** 2 ) * r ** 2) + \\\n",
" np.tan(alpha) * dlength_dy(y)\n",
" # return np.tan(alpha) * dlength_dy(y)\n",
" \n",
" def distance_yp(y, t):\n",
" return np.sqrt((y_p - y) ** 2 + z(y, t) ** 2)\n",
" \n",
" def ddistance_yp_dy(y, t):\n",
" return (y - y_p + z(y, t) * dz_dy(y)) / distance_yp(y, t)\n",
" \n",
" def distance_ythales(y, t):\n",
" return np.sqrt((y_thales - y) ** 2 + z(y, t) ** 2)\n",
" \n",
" def min_ground(pars):\n",
" y, t = pars\n",
" # return the normal-condition + the intesection of the tooth-flank with the thales circle\n",
" return ddistance_yp_dy(y, t) ** 2 + (distance_ythales(y, t) - r_thales) ** 2\n",
"\n",
" def min_head(pars):\n",
" y, t = pars\n",
" r_0 = y_p - module # * (1 + clearence)\n",
" y_inner = r_0 * np.cos(np.arcsin(x / r_0))\n",
" return ddistance_yp_dy(y, t) ** 2 + (y - y_inner) ** 2\n",
"\n",
" def analytic_solution_for_x_0():\n",
" t = - (r_w + y_p) * np.tan(alpha)\n",
" y = y_p + r_w * np.sin(alpha) ** 2\n",
" return np.array([y, t])\n",
" \n",
" start = analytic_solution_for_x_0()\n",
" if debug:\n",
" print(f\"analytic solution: {analytic_solution_for_x_0()}\")\n",
" print(f\"min_ground analytic: {min_ground(start)}\")\n",
" print(f\"thales analytic: {distance_ythales(start[0], start[1]) - r_thales}\")\n",
" print(f\"normal analytic: {ddistance_yp_dy(start[0], start[1])}\")\n",
" print()\n",
"\n",
"\n",
" xyz = []\n",
" for x in np.linspace(-height / 2, height / 2, 20):\n",
" xyz_section = []\n",
" t_start = sp.optimize.minimize(min_ground, start).x[1]\n",
" # t_end = sp.optimize.minimize(min_head, [y_p, 0.]).x[1]\n",
" t_end = 3\n",
" for t in np.linspace(t_start, t_end, 20):\n",
" # compute the transformation\n",
" T0 = numeric_transformation((y_p * np.tan(alpha) + np.sign(alpha) * module * np.pi / 4) / r_w,\n",
" np.array([0., 0., 1.]), \n",
" np.array([0., 0.,0.]))\n",
" T1 = numeric_transformation(np.pi / 2.,\n",
" np.array([0., 1., 0.]),\n",
" np.array([0., y_p + r_w, 0.]))\n",
" T2 = numeric_transformation(-t / r_w,\n",
" np.array([0., 0., 1.]),\n",
" np.array([0., 0., 0.]))\n",
" T = T0 @ np.linalg.inv(T2) @ np.linalg.inv(T1)\n",
" y = sp.optimize.minimize(distance_yp, y_p, (t)).x[0]\n",
" z_i = z(y, t) # - y_p * np.tan(alpha) + np.sign(alpha) * module * np.pi / 4\n",
" point = np.array([x, y, z_i, 1.])\n",
" xyz_section.append((T @ point)[:3])\n",
" xyz.append(np.array(xyz_section))\n",
"\n",
" return np.array(xyz)\n",
"\n",
"\n",
"curves = []\n",
"for line in compute().transpose(1, 0, 2):\n",
" bs = part.BSplineCurve()\n",
" points = [app.Vector(*point) for point in line]\n",
" bs.interpolate(points)\n",
" curves.append(bs.toShape())\n",
"\n",
"part.show(part.makeLoft(curves))"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "d804123e-3a1f-418a-b042-3619b1286c29",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2]"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[1,2,3,4][:2]"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "301cc8e3-b28d-4f36-8fc2-f4333d4f0bf1",
"id": "012a264b-12b2-4fa3-a734-60251262e914",
"metadata": {},
"outputs": [],
"source": [
"import scipy as scp\n",
"def contact_point(m, n_t, alpha, rw_worm):\n",
" def z(x, y, t):\n",
" r = np.sqrt(x ** 2 + y ** 2)\n",
" return m * n_t * np.asin(x / r) + r * np.tan(alpha) + t\n",
"\n",
" def contact_point(x, t):\n",
" def distance_to_pitch_point(y):\n",
" return (y - rw_worm) ** 2 + z(x, y, t) ** 2\n",
"\n",
" y = scp.optimize.minimize(distance_to_pitch_point, rw_worm).x\n",
" return np.array([x, y, z(x, y, t)]"
]
"source": []
}
],
"metadata": {

2
setup.py
View File

@@ -9,6 +9,6 @@ setup(
maintainer_email="sppedflyer@gmail.com",
url="https://github.com/looooo/FCGear",
description="gears for FreeCAD",
install_requires=["numpy", "scipy"],
install_requires=["numpy", "scipy", "sympy"],
include_package_data=True,
)