{ "cells": [ { "cell_type": "markdown", "id": "a0475cb8", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "# The 30 Degree Rule\n", "\n", "## Intro\n", "\n", "The 30 degree rule states that the cue ball, when colliding with a ball over a wide range of cut angles, will be deflected roughly 30 degrees from it's initial course after the collision. It is more of a *rule of thumb* used by pool players to improve their game, rather than a truism of pool physics.\n", "\n", "In this example, we will setup simulations that test the 30 degree rule and some of the physics equations defined by [Dr. Dave Billiards](https://drdavebilliards.com/).\n", "\n", "## Assumptions\n", "\n", "We'll use one of pooltool's simpler ball-ball models which assumes perfectly elastic and frictionless ball-ball collisions. Read more [here](https://ekiefl.github.io/2020/04/24/pooltool-theory/#section-ii-ball-ball-interactions).\n", "\n", "Importantly, the cue ball must be rolling (without slippage) when it contacts the object ball. Otherwise, the 30-degree rule will not hold. As an extreme example of this, a cue ball with no spin will deflect off the object ball along the [tangent line](https://billiards.colostate.edu/faq/stun/90-degree-rule/).\n", "\n", "## Definitions\n", "\n", "**The rule, stated in full:**\n", "\n", "> The 30° rule states that for a rolling cue ball (CB) shot, over a wide range of cut angles, between a 1/4-ball hit (49 degree cut) and 3/4-ball hit (14 degree cut), the CB will deflect or carom off by very close to 30° (the “natural angle“) from its original direction after hitting the object ball (OB). If you want to be more precise, the angle is a little more (about 34°) closer to a 1/2-ball hit and a little less (about 27°) closer to a 1/4-ball or 3/4-ball hit.\n", "\n", "*(source: [https://billiards.colostate.edu/faq/30-90-rules/30-degree-rule/](https://billiards.colostate.edu/faq/30-90-rules/30-degree-rule/))*\n", "\n", "**The carom angle**\n", "\n", "The carom angle is the angle that the rule claims is 30 degrees. Formally, it is the angle between the velocity of the cue ball directly before impact, and the velocity of the cue ball after the collision once the cue ball is no longer sliding on the cloth. We will see that this angle is independent of the cue's initial speed.\n", "\n", "**Ball-hit fraction and cut angle**\n", "\n", "- Ball-hit fraction, $f$, describes the fraction of overlap between the cue ball and object ball, projected in the direction of the aiming line.\n", "- Cut angle, $\\phi$, refers to the angle that the cue ball glances the object ball, where $0$ refers to a full ball hit (straight on), and $90$ refers to the lower bound of the thinnest hit possible.\n", "\n", "These two are visualized in this diagram, where $f = \\text{ball overlap} / (2R)$:\n", "\n", "\n", "\n", "*(source: [https://billiards.colostate.edu/technical_proofs/new/TP_A-23.pdf](https://billiards.colostate.edu/technical_proofs/new/TP_A-23.pdf))*\n", "\n", "Establishing the relationship between these quantities is important, since the 30 degree rule makes reference to both cut angle and ball-hit fraction. One can calculate the ball-hit fraction from cut angle with the following equation:\n", "\n", "$$\n", "f(\\phi) = 1 - \\sin{\\phi}\n", "$$" ] }, { "cell_type": "markdown", "id": "329f9243", "metadata": {}, "source": [ "## Simulating a collision\n", "\n", "To start, we'll need to create a billiards system. That means defining a table, a cue stick, and a collection of balls.\n", "\n", "We'll start with a table. Since we don't want collisions with cushions to interfere with our trajectory, let's make an unrealistically large $10\\text{m} \\times 10\\text{m}$ [Table](../autoapi/pooltool/index.rst#pooltool.Table)." ] }, { "cell_type": "code", "execution_count": 1, "id": "0ab855d2", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:55.679702Z", "iopub.status.busy": "2025-06-02T02:34:55.679334Z", "iopub.status.idle": "2025-06-02T02:34:56.435306Z", "shell.execute_reply": "2025-06-02T02:34:56.434470Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "import pooltool as pt\n", "\n", "table_specs = pt.objects.BilliardTableSpecs(l=10, w=10)\n", "table = pt.Table.from_table_specs(table_specs)" ] }, { "cell_type": "markdown", "id": "c84af7d9", "metadata": {}, "source": [ "Next, we'll create two [Ball](../autoapi/pooltool/index.rst#pooltool.Ball) objects." ] }, { "cell_type": "code", "execution_count": 2, "id": "098c6d65", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:56.438978Z", "iopub.status.busy": "2025-06-02T02:34:56.438519Z", "iopub.status.idle": "2025-06-02T02:34:56.765751Z", "shell.execute_reply": "2025-06-02T02:34:56.764782Z" } }, "outputs": [], "source": [ "cue_ball = pt.Ball.create(\"cue\", xy=(2.5, 1.5))\n", "obj_ball = pt.Ball.create(\"obj\", xy=(2.5, 3.0))" ] }, { "cell_type": "markdown", "id": "5772615e", "metadata": {}, "source": [ "Next, we'll need a [Cue](../autoapi/pooltool/index.rst#pooltool.Cue)." ] }, { "cell_type": "code", "execution_count": 3, "id": "11a26169", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:56.769624Z", "iopub.status.busy": "2025-06-02T02:34:56.769062Z", "iopub.status.idle": "2025-06-02T02:34:56.772827Z", "shell.execute_reply": "2025-06-02T02:34:56.772302Z" } }, "outputs": [], "source": [ "cue = pt.Cue(cue_ball_id=\"cue\")" ] }, { "cell_type": "markdown", "id": "26714c28", "metadata": {}, "source": [ "Finally, we'll need to wrap these objects up into a [System](../autoapi/pooltool/index.rst#pooltool.System). We'll call this our system *template*, with the intention of reusing it for many different shots." ] }, { "cell_type": "code", "execution_count": 4, "id": "13b3d613", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:56.775815Z", "iopub.status.busy": "2025-06-02T02:34:56.775532Z", "iopub.status.idle": "2025-06-02T02:34:56.778782Z", "shell.execute_reply": "2025-06-02T02:34:56.778257Z" } }, "outputs": [], "source": [ "system_template = pt.System(\n", " table=table,\n", " cue=cue,\n", " balls=(cue_ball, obj_ball),\n", ")" ] }, { "cell_type": "markdown", "id": "937977d6", "metadata": {}, "source": [ "Let's set up a shot by aiming at the object ball with a cut angle of 30 degrees. There is a small clash in terminology here, because in pooltool, `phi` is an angle defined with respect to the table, not the cut angle:\n", "\n", "\n", "\n", "So in the function call below, `pt.aim.at_ball(system, \"obj\", cut=30)` returns the angle `phi` that the cue ball should be directed at such that a cut angle of 30 degrees with the object ball is achieved." ] }, { "cell_type": "code", "execution_count": 5, "id": "ef0802b2", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:56.781832Z", "iopub.status.busy": "2025-06-02T02:34:56.781350Z", "iopub.status.idle": "2025-06-02T02:34:56.855058Z", "shell.execute_reply": "2025-06-02T02:34:56.854118Z" } }, "outputs": [], "source": [ "# Creates a deep copy of the template\n", "system = system_template.copy()\n", "\n", "phi = pt.aim.at_ball(system, \"obj\", cut=30)\n", "system.cue.set_state(V0=3, phi=phi, b=0.4)" ] }, { "cell_type": "markdown", "id": "232cb6c2", "metadata": {}, "source": [ "Now, we [simulate](../autoapi/pooltool/index.rst#pooltool.simulate) the shot and then [continuize](../autoapi/pooltool/evolution/continuize/index.html#pooltool.evolution.continuize.continuize) it to store ball state data (like coordinates) in $10\\text{ms}$ timestep intervals." ] }, { "cell_type": "code", "execution_count": 6, "id": "d29a2bda", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:56.858374Z", "iopub.status.busy": "2025-06-02T02:34:56.858075Z", "iopub.status.idle": "2025-06-02T02:34:57.073492Z", "shell.execute_reply": "2025-06-02T02:34:57.072556Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "System simulated: True\n" ] } ], "source": [ "# Create a default physics engine, then overwrite ball-ball model with frictionless, elastic model.\n", "engine = pt.physics.PhysicsEngine()\n", "engine.resolver.ball_ball = pt.physics.ball_ball_models[pt.physics.BallBallModel.FRICTIONLESS_ELASTIC]()\n", "\n", "pt.simulate(system, engine=engine, inplace=True)\n", "pt.continuize(system, dt=0.01, inplace=True)\n", "\n", "print(f\"System simulated: {system.simulated}\")" ] }, { "cell_type": "markdown", "id": "0debc0af", "metadata": {}, "source": [ "## Visualizing the collision" ] }, { "cell_type": "markdown", "id": "cbd37f0d", "metadata": {}, "source": [ "If you have a graphics card, you can immediately visualize this shot in 3D with\n", "\n", "```python\n", "pt.show(system)\n", "```\n", "\n", "Since that can't be embedded into the documentation, we'll instead plot the trajectory of the cue ball and object ball by accessing ther historical states." ] }, { "cell_type": "code", "execution_count": 7, "id": "ffab2ecc", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.077298Z", "iopub.status.busy": "2025-06-02T02:34:57.076958Z", "iopub.status.idle": "2025-06-02T02:34:57.084935Z", "shell.execute_reply": "2025-06-02T02:34:57.084159Z" } }, "outputs": [ { "data": { "text/plain": [ "pooltool.objects.ball.datatypes.BallHistory" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cue_ball = system.balls[\"cue\"]\n", "obj_ball = system.balls[\"obj\"]\n", "cue_history = cue_ball.history_cts\n", "obj_history = obj_ball.history_cts\n", "type(cue_history)" ] }, { "cell_type": "markdown", "id": "3103fb30", "metadata": {}, "source": [ "The [BallHistory](../autoapi/pooltool/objects/index.rst#pooltool.objects.BallHistory) holds the ball's historical states, each stored as a [BallState](../autoapi/pooltool/objects/index.rst#pooltool.objects.BallState) object. Each attribute of the ball states can be concatenated into numpy arrays with the [BallHistory.vectorize](../autoapi/pooltool/objects/index.rst#pooltool.objects.BallHistory.vectorize) method." ] }, { "cell_type": "code", "execution_count": 8, "id": "e82a222e", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.088572Z", "iopub.status.busy": "2025-06-02T02:34:57.087928Z", "iopub.status.idle": "2025-06-02T02:34:57.096635Z", "shell.execute_reply": "2025-06-02T02:34:57.095788Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1352, 3, 3)\n", "(1352,)\n", "(1352,)\n" ] } ], "source": [ "rvw_cue, s_cue, t_cue = cue_history.vectorize()\n", "rvw_obj, s_obj, t_obj = obj_history.vectorize()\n", "\n", "print(rvw_cue.shape)\n", "print(s_cue.shape)\n", "print(t_cue.shape)" ] }, { "cell_type": "markdown", "id": "46a2bc8b", "metadata": {}, "source": [ "We can grab the xy-coordinates from the `rvw` array by with the following." ] }, { "cell_type": "code", "execution_count": 9, "id": "de1ed3f0", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.100169Z", "iopub.status.busy": "2025-06-02T02:34:57.099712Z", "iopub.status.idle": "2025-06-02T02:34:57.105527Z", "shell.execute_reply": "2025-06-02T02:34:57.104633Z" } }, "outputs": [ { "data": { "text/plain": [ "(1352, 2)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "coords_cue = rvw_cue[:, 0, :2]\n", "coords_obj = rvw_obj[:, 0, :2]\n", "coords_cue.shape" ] }, { "cell_type": "code", "execution_count": 10, "id": "9a2d85fe", "metadata": { "editable": true, "execution": { "iopub.execute_input": "2025-06-02T02:34:57.109410Z", "iopub.status.busy": "2025-06-02T02:34:57.109033Z", "iopub.status.idle": "2025-06-02T02:34:57.736017Z", "shell.execute_reply": "2025-06-02T02:34:57.735341Z" }, "lines_to_next_cell": 2, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import plotly.graph_objects as go\n", "import plotly.io as pio\n", "\n", "pio.renderers.default = \"sphinx_gallery\"\n", "\n", "fig = go.Figure()\n", "fig.add_trace(\n", " go.Scatter(x=coords_cue[:, 0], y=coords_cue[:, 1], mode=\"lines\", name=\"cue\")\n", ")\n", "fig.add_trace(\n", " go.Scatter(x=coords_obj[:, 0], y=coords_obj[:, 1], mode=\"lines\", name=\"obj\")\n", ")\n", "fig.update_layout(\n", " title=\"Ball trajectories\",\n", " xaxis_title=\"X [m]\",\n", " yaxis_title=\"Y [m]\",\n", " yaxis_scaleanchor=\"x\",\n", " yaxis_scaleratio=1,\n", " width=600,\n", " template=\"presentation\",\n", ")\n", "\n", "fig.show()" ] }, { "cell_type": "markdown", "id": "d714b7a7", "metadata": {}, "source": [ "## Calculating the carom angle\n", "\n", "One could calculate the carom angle for the above trajectory by manually splicing the trajectory coordinates of the cue ball and determining ball direction by comparing temporally adjacent coordinates. However, pooltool has much more precise methods for dissecting shot dynamics.\n", "\n", "As mentioned before, the carom angle is the angle between the cue ball velocity right before collision, and the cue ball velocity post-collision, once the ball has stopped sliding on the cloth. Hidden somewhere in the system **event list** one can find the events corresponding to these precise moments in time:" ] }, { "cell_type": "code", "execution_count": 11, "id": "2b72e729", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.738700Z", "iopub.status.busy": "2025-06-02T02:34:57.738448Z", "iopub.status.idle": "2025-06-02T02:34:57.743504Z", "shell.execute_reply": "2025-06-02T02:34:57.742904Z" } }, "outputs": [ { "data": { "text/plain": [ "[\n", " ├── type : none\n", " ├── time : 0\n", " └── agents : ('dummy',),\n", " \n", " ├── type : stick_ball\n", " ├── time : 0\n", " └── agents : ('cue_stick', 'cue'),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 6.467004657784513e-17\n", " └── agents : ('cue',),\n", " \n", " ├── type : ball_ball\n", " ├── time : 0.4132706782912061\n", " └── agents : ('cue', 'obj'),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 0.8533126707158925\n", " └── agents : ('obj',),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 0.8533126707158927\n", " └── agents : ('cue',)]" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "system.events[:6]" ] }, { "cell_type": "markdown", "id": "c87c88a4", "metadata": {}, "source": [ "Programatically, we can pick out these two events of interest with event selection syntax.\n", "\n", "Since there is only one ball-ball collision, it's easy to select with [filter_type](../autoapi/pooltool/events/index.rst#pooltool.events.filter_type):" ] }, { "cell_type": "code", "execution_count": 12, "id": "826ceca7", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.746650Z", "iopub.status.busy": "2025-06-02T02:34:57.746310Z", "iopub.status.idle": "2025-06-02T02:34:57.750960Z", "shell.execute_reply": "2025-06-02T02:34:57.750436Z" } }, "outputs": [ { "data": { "text/plain": [ "\n", " ├── type : ball_ball\n", " ├── time : 0.4132706782912061\n", " └── agents : ('cue', 'obj')" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "collision = pt.events.filter_type(system.events, pt.EventType.BALL_BALL)[0]\n", "collision" ] }, { "cell_type": "markdown", "id": "37edcb1e", "metadata": {}, "source": [ "To get the event when the cue ball stops sliding, we can similarly try filtering by the sliding to rolling transition event:" ] }, { "cell_type": "code", "execution_count": 13, "id": "c1154201", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.753679Z", "iopub.status.busy": "2025-06-02T02:34:57.753434Z", "iopub.status.idle": "2025-06-02T02:34:57.758114Z", "shell.execute_reply": "2025-06-02T02:34:57.757573Z" } }, "outputs": [ { "data": { "text/plain": [ "[\n", " ├── type : sliding_rolling\n", " ├── time : 6.467004657784513e-17\n", " └── agents : ('cue',),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 0.8533126707158925\n", " └── agents : ('obj',),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 0.8533126707158927\n", " └── agents : ('cue',),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 2.9537094941822026\n", " └── agents : ('obj',),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 4.841243735194121\n", " └── agents : ('obj',),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 5.628109523804255\n", " └── agents : ('cue',),\n", " \n", " ├── type : sliding_rolling\n", " ├── time : 11.98683196671916\n", " └── agents : ('cue',)]" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pt.events.filter_type(system.events, pt.EventType.SLIDING_ROLLING)" ] }, { "cell_type": "markdown", "id": "81d460b3", "metadata": {}, "source": [ "But there are many sliding to rolling transition events, and to make matters worse, they are shared by both the cue ball and the object ball. What we need is the **first** **sliding to rolling** transition that the **cue ball** undergoes **after** the **ball-ball** collision. We can achieve this multi-criteria query with [filter_events](../autoapi/pooltool/events/index.rst#pooltool.events.filter_events):" ] }, { "cell_type": "code", "execution_count": 14, "id": "2f0cea92", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.760587Z", "iopub.status.busy": "2025-06-02T02:34:57.760234Z", "iopub.status.idle": "2025-06-02T02:34:57.764338Z", "shell.execute_reply": "2025-06-02T02:34:57.763833Z" } }, "outputs": [ { "data": { "text/plain": [ "\n", " ├── type : sliding_rolling\n", " ├── time : 0.8533126707158927\n", " └── agents : ('cue',)" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "transition = pt.events.filter_events(\n", " system.events,\n", " pt.events.by_time(t=collision.time, after=True),\n", " pt.events.by_ball(\"cue\"),\n", " pt.events.by_type(pt.EventType.SLIDING_ROLLING),\n", ")[0]\n", "transition" ] }, { "cell_type": "markdown", "id": "dd8332a2", "metadata": {}, "source": [ "Now, we can dive into these two events and pull out the cue ball velocities we need to calculate the carom angle." ] }, { "cell_type": "code", "execution_count": 15, "id": "c3bdca19", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.766665Z", "iopub.status.busy": "2025-06-02T02:34:57.766454Z", "iopub.status.idle": "2025-06-02T02:34:57.770675Z", "shell.execute_reply": "2025-06-02T02:34:57.770129Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The carom angle is 33.7 degrees\n" ] } ], "source": [ "# Velocity prior to impact\n", "velocity_initial = collision.get_ball(\"cue\", initial=True).vel[:2]\n", "\n", "# Velocity post sliding\n", "# We choose the \"final\" here for posterity, but the velocity is the same both before and after resolving the transition.\n", "velocity_final = transition.get_ball(\"cue\", initial=False).vel[:2]\n", "\n", "carom_angle = pt.ptmath.utils.angle_between_vectors(velocity_final, velocity_initial)\n", "\n", "print(f\"The carom angle is {carom_angle:.1f} degrees\")" ] }, { "cell_type": "markdown", "id": "3bbe7aef", "metadata": {}, "source": [ "## Carom angle as a function of cut angle" ] }, { "cell_type": "markdown", "id": "a3524ecc", "metadata": { "lines_to_next_cell": 2 }, "source": [ "We calculated the carom angle for a single cut angle, 30 degrees. Let's write a function called `get_carom_angle` so we can do that repeatedly for different cut angles." ] }, { "cell_type": "code", "execution_count": 16, "id": "f710dc79", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.773036Z", "iopub.status.busy": "2025-06-02T02:34:57.772814Z", "iopub.status.idle": "2025-06-02T02:34:57.776926Z", "shell.execute_reply": "2025-06-02T02:34:57.776308Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "def get_carom_angle(system: pt.System) -> float:\n", " assert system.simulated\n", "\n", " collision = pt.events.filter_type(system.events, pt.EventType.BALL_BALL)[0]\n", " transition = pt.events.filter_events(\n", " system.events,\n", " pt.events.by_time(t=collision.time, after=True),\n", " pt.events.by_ball(\"cue\"),\n", " pt.events.by_type(pt.EventType.SLIDING_ROLLING),\n", " )[0]\n", "\n", " velocity_final = transition.get_ball(\"cue\", initial=False).state.rvw[1, :2]\n", " velocity_initial = collision.get_ball(\"cue\", initial=True).state.rvw[1, :2]\n", "\n", " return pt.ptmath.utils.angle_between_vectors(velocity_final, velocity_initial)" ] }, { "cell_type": "markdown", "id": "ca540c4f", "metadata": { "lines_to_next_cell": 2 }, "source": [ "`get_carom_angle` assumes the passed system has already been simulated, so we'll need another function to take care of that. We'll cue stick speed and cut angle as parameters." ] }, { "cell_type": "code", "execution_count": 17, "id": "bf386ee0", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.779691Z", "iopub.status.busy": "2025-06-02T02:34:57.779348Z", "iopub.status.idle": "2025-06-02T02:34:57.783035Z", "shell.execute_reply": "2025-06-02T02:34:57.782505Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "def simulate_experiment(V0: float, cut_angle: float) -> pt.System:\n", " system = system_template.copy()\n", " phi = pt.aim.at_ball(system, \"obj\", cut=cut_angle)\n", " system.cue.set_state(V0=V0, phi=phi, b=0.4)\n", " pt.simulate(system, engine=engine, inplace=True)\n", " return system" ] }, { "cell_type": "markdown", "id": "2ba3e216", "metadata": { "lines_to_next_cell": 2 }, "source": [ "We'll also want the ball hit fraction:" ] }, { "cell_type": "code", "execution_count": 18, "id": "8673f181", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.785573Z", "iopub.status.busy": "2025-06-02T02:34:57.785327Z", "iopub.status.idle": "2025-06-02T02:34:57.788631Z", "shell.execute_reply": "2025-06-02T02:34:57.788093Z" } }, "outputs": [], "source": [ "import numpy as np\n", "\n", "def get_ball_hit_fraction(cut_angle: float) -> float:\n", " return 1 - np.sin(cut_angle * np.pi / 180)" ] }, { "cell_type": "markdown", "id": "336b59ec", "metadata": {}, "source": [ "With these functions, we are ready to simulate how carom angle varies as a function of cut angle." ] }, { "cell_type": "code", "execution_count": 19, "id": "a414c186", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:57.791098Z", "iopub.status.busy": "2025-06-02T02:34:57.790858Z", "iopub.status.idle": "2025-06-02T02:34:57.948057Z", "shell.execute_reply": "2025-06-02T02:34:57.947388Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "cut_angle=np.float64(2.0)\n", "cut_angle=np.float64(3.7551020408163263)\n", "cut_angle=np.float64(5.5102040816326525)\n", "cut_angle=np.float64(7.26530612244898)\n", "cut_angle=np.float64(9.020408163265305)\n", "cut_angle=np.float64(10.775510204081632)\n", "cut_angle=np.float64(12.53061224489796)\n", "cut_angle=np.float64(14.285714285714285)\n", "cut_angle=np.float64(16.04081632653061)\n", "cut_angle=np.float64(17.79591836734694)\n", "cut_angle=np.float64(19.551020408163264)\n", "cut_angle=np.float64(21.30612244897959)\n", "cut_angle=np.float64(23.06122448979592)\n", "cut_angle=np.float64(24.816326530612244)\n", "cut_angle=np.float64(26.57142857142857)\n", "cut_angle=np.float64(28.3265306122449)\n", "cut_angle=np.float64(30.081632653061224)\n", "cut_angle=np.float64(31.83673469387755)\n", "cut_angle=np.float64(33.59183673469388)\n", "cut_angle=np.float64(35.3469387755102)\n", "cut_angle=np.float64(37.10204081632653)\n", "cut_angle=np.float64(38.857142857142854)\n", "cut_angle=np.float64(40.61224489795918)\n", "cut_angle=np.float64(42.36734693877551)\n", "cut_angle=np.float64(44.12244897959184)\n", "cut_angle=np.float64(45.87755102040816)\n", "cut_angle=np.float64(47.63265306122449)\n", "cut_angle=np.float64(49.38775510204081)\n", "cut_angle=np.float64(51.14285714285714)\n", "cut_angle=np.float64(52.89795918367347)\n", "cut_angle=np.float64(54.6530612244898)\n", "cut_angle=np.float64(56.40816326530612)\n", "cut_angle=np.float64(58.16326530612245)\n", "cut_angle=np.float64(59.91836734693877)\n", "cut_angle=np.float64(61.6734693877551)\n", "cut_angle=np.float64(63.42857142857142)\n", "cut_angle=np.float64(65.18367346938776)\n", "cut_angle=np.float64(66.93877551020408)\n", "cut_angle=np.float64(68.6938775510204)\n", "cut_angle=np.float64(70.44897959183673)\n", "cut_angle=np.float64(72.20408163265306)\n", "cut_angle=np.float64(73.95918367346938)\n", "cut_angle=np.float64(75.71428571428571)\n", "cut_angle=np.float64(77.46938775510203)\n", "cut_angle=np.float64(79.22448979591836)\n", "cut_angle=np.float64(80.9795918367347)\n", "cut_angle=np.float64(82.73469387755102)\n", "cut_angle=np.float64(84.48979591836735)\n", "cut_angle=np.float64(86.24489795918367)\n", "cut_angle=np.float64(88.0)\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
phiftheta
02.0000000.9651014.971244
13.7551020.9345089.208701
25.5102040.90397713.139984
37.2653060.87353616.757206
49.0204080.84321420.060728
510.7755100.81303922.879233
612.5306120.78303925.358318
714.2857140.75324327.429965
816.0408160.72367829.132091
917.7959180.69437330.525388
\n", "
" ], "text/plain": [ " phi f theta\n", "0 2.000000 0.965101 4.971244\n", "1 3.755102 0.934508 9.208701\n", "2 5.510204 0.903977 13.139984\n", "3 7.265306 0.873536 16.757206\n", "4 9.020408 0.843214 20.060728\n", "5 10.775510 0.813039 22.879233\n", "6 12.530612 0.783039 25.358318\n", "7 14.285714 0.753243 27.429965\n", "8 16.040816 0.723678 29.132091\n", "9 17.795918 0.694373 30.525388" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "data = {\n", " \"phi\": [],\n", " \"f\": [],\n", " \"theta\": [],\n", "}\n", "\n", "V0 = 2.5\n", "\n", "for cut_angle in np.linspace(2, 88, 50):\n", " print(f\"{cut_angle=}\")\n", " system = simulate_experiment(V0, cut_angle)\n", " data[\"theta\"].append(get_carom_angle(system))\n", " data[\"f\"].append(get_ball_hit_fraction(cut_angle))\n", " data[\"phi\"].append(cut_angle)\n", "\n", "frame = pd.DataFrame(data)\n", "frame.head(10)" ] }, { "cell_type": "markdown", "id": "484d1311", "metadata": {}, "source": [ "From this dataframe we can make some plots. On top of the ball-hit fraction, plot, I'll create a box between a $1/4$ ball hit and a $3/4$ ball hit, since this is the carom angle range that the 30-degree rule is defined with respect to." ] }, { "cell_type": "code", "execution_count": 20, "id": "e6cf2257", "metadata": { "editable": true, "execution": { "iopub.execute_input": "2025-06-02T02:34:57.951163Z", "iopub.status.busy": "2025-06-02T02:34:57.950872Z", "iopub.status.idle": "2025-06-02T02:34:58.950920Z", "shell.execute_reply": "2025-06-02T02:34:58.950075Z" }, "slideshow": { "slide_type": "" }, "tags": [ "nbsphinx-thumbnail" ] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "x_min = 0.25\n", "x_max = 0.75\n", "y_min = frame.loc[(frame.f >= x_min) & (frame.f <= x_max), \"theta\"].min()\n", "y_max = frame.loc[(frame.f >= x_min) & (frame.f <= x_max), \"theta\"].max()\n", "box_data_x = [x_min, x_min, x_max, x_max, x_min]\n", "box_data_y = [y_min, y_max, y_max, y_min, y_min]\n", "\n", "fig, ax = plt.subplots()\n", "ax.plot(box_data_x, box_data_y, linestyle='--', color='gray', label='30-degree range')\n", "ax.scatter(frame['f'], frame['theta'], color='#1f77b4', label='Simulation')\n", "ax.set_title('Carom Angle vs Ball Hit Fraction', fontsize=20)\n", "ax.set_xlabel('Ball Hit Fraction (f)', fontsize=16)\n", "ax.set_ylabel('Carom Angle (theta, degrees)', fontsize=16)\n", "ax.tick_params(axis='both', which='major', labelsize=14)\n", "ax.legend(fontsize=14)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "46238979", "metadata": {}, "source": [ "Between a $1/4$ and $3/4$ ball hit, there is a relative invariance in the carom angle, with a range of around 6 degrees.\n", "\n", "For your reference, here is the same plot but with cut angle $\\phi$ as the x-axis:" ] }, { "cell_type": "code", "execution_count": 21, "id": "78496980", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:58.955498Z", "iopub.status.busy": "2025-06-02T02:34:58.954562Z", "iopub.status.idle": "2025-06-02T02:34:59.102906Z", "shell.execute_reply": "2025-06-02T02:34:59.102129Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots()\n", "ax.scatter(frame['phi'], frame['theta'], color='#1f77b4')\n", "ax.set_title('Carom Angle vs Cut Angle', fontsize=20)\n", "ax.set_xlabel('Cut Angle (phi)', fontsize=16)\n", "ax.set_ylabel('Carom Angle (theta, degrees)', fontsize=16)\n", "ax.tick_params(axis='both', which='major', labelsize=14)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "f2505b3c", "metadata": { "lines_to_next_cell": 2 }, "source": [ "## Comparison to theory\n", "\n", "Under the assumption of a perfectly elastic and frictionless ball-ball collision, Dr. Dave has calculated the theoretical carom angle $\\theta$ to be\n", "\n", "$$\n", "\\theta_{\\text{ideal}}(\\phi) = \\arctan{\\frac{\\sin\\phi \\times \\cos\\phi}{\\sin^2\\phi + \\frac{2}{5}}}\n", "$$\n", "\n", "*(source: [https://billiards.colostate.edu/technical_proofs/new/TP_B-13.pdf](https://billiards.colostate.edu/technical_proofs/new/TP_B-13.pdf))*\n", "\n", "Since pooltool's baseline physics engine makes the same assumptions, we should expect the results to be the same. Let's directly compare:" ] }, { "cell_type": "code", "execution_count": 22, "id": "79522ddc", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:59.106367Z", "iopub.status.busy": "2025-06-02T02:34:59.106035Z", "iopub.status.idle": "2025-06-02T02:34:59.329959Z", "shell.execute_reply": "2025-06-02T02:34:59.329341Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def get_theoretical_carom_angle(phi) -> float:\n", " return np.atan2(np.sin(phi) * np.cos(phi), (np.sin(phi) ** 2 + 2 / 5))\n", "\n", "phi_theory = np.linspace(0, np.pi / 2, 500)\n", "theta_theory = get_theoretical_carom_angle(phi_theory)\n", "\n", "phi_theory *= 180 / np.pi\n", "theta_theory *= 180 / np.pi\n", "f_theory = get_ball_hit_fraction(phi_theory)\n", "\n", "fig = go.Figure()\n", "fig.add_trace(\n", " go.Scatter(\n", " x=box_data_x,\n", " y=box_data_y,\n", " mode=\"lines\",\n", " name=\"30-degree range\",\n", " line=dict(dash=\"dash\", color=\"gray\"),\n", " )\n", ")\n", "fig.add_trace(\n", " go.Scatter(\n", " x=frame[\"f\"],\n", " y=frame[\"theta\"],\n", " mode=\"markers\",\n", " name=\"Simulation\",\n", " marker=dict(color=\"#1f77b4\"),\n", " )\n", ")\n", "fig.add_trace(go.Scatter(x=f_theory, y=theta_theory, mode=\"lines\", name=\"Theory\"))\n", "fig.update_layout(\n", " title=\"Carom Angle vs Ball Hit Fraction\",\n", " xaxis_title=\"Ball Hit Fraction (f)\",\n", " yaxis_title=\"Carom Angle (theta, degrees)\",\n", " template=\"presentation\",\n", ")\n", "fig.show()" ] }, { "cell_type": "markdown", "id": "b31dda08", "metadata": {}, "source": [ "A perfect match." ] }, { "cell_type": "markdown", "id": "d99aab20", "metadata": {}, "source": [ "## Impact speed independence\n", "\n", "Interestingly, the carom angle is independent of the speed:" ] }, { "cell_type": "code", "execution_count": 23, "id": "808557dc", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:59.333541Z", "iopub.status.busy": "2025-06-02T02:34:59.333233Z", "iopub.status.idle": "2025-06-02T02:34:59.396908Z", "shell.execute_reply": "2025-06-02T02:34:59.396330Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Carom angle for V0=1.000000 is 33.671326\n", "Carom angle for V0=1.157895 is 33.671326\n", "Carom angle for V0=1.315789 is 33.671326\n", "Carom angle for V0=1.473684 is 33.671326\n", "Carom angle for V0=1.631579 is 33.671326\n", "Carom angle for V0=1.789474 is 33.671326\n", "Carom angle for V0=1.947368 is 33.671326\n", "Carom angle for V0=2.105263 is 33.671326\n", "Carom angle for V0=2.263158 is 33.671326\n", "Carom angle for V0=2.421053 is 33.671326\n", "Carom angle for V0=2.578947 is 33.671326\n", "Carom angle for V0=2.736842 is 33.671326\n", "Carom angle for V0=2.894737 is 33.671326\n", "Carom angle for V0=3.052632 is 33.671326\n", "Carom angle for V0=3.210526 is 33.671326\n", "Carom angle for V0=3.368421 is 33.671326\n", "Carom angle for V0=3.526316 is 33.671326\n", "Carom angle for V0=3.684211 is 33.671326\n", "Carom angle for V0=3.842105 is 33.671326\n", "Carom angle for V0=4.000000 is 33.671326\n" ] } ], "source": [ "for V0 in np.linspace(1, 4, 20):\n", " system = simulate_experiment(V0, 30)\n", " carom_angle = get_carom_angle(system)\n", " print(f\"Carom angle for V0={V0:2f} is {carom_angle:4f}\")" ] }, { "cell_type": "markdown", "id": "d6b9356d", "metadata": {}, "source": [ "This doesn't mean that the trajectories are the same though. Here are the trajectories:" ] }, { "cell_type": "code", "execution_count": 24, "id": "f6c04d1e", "metadata": { "execution": { "iopub.execute_input": "2025-06-02T02:34:59.399918Z", "iopub.status.busy": "2025-06-02T02:34:59.399674Z", "iopub.status.idle": "2025-06-02T02:34:59.456977Z", "shell.execute_reply": "2025-06-02T02:34:59.456375Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "import plotly.graph_objects as go\n", "\n", "\n", "def get_coordinates(system: pt.System):\n", " rvw, s, t = system.balls[\"cue\"].history_cts.vectorize()\n", " xy = rvw[:, 0, :2]\n", "\n", " return xy, s, t\n", "\n", "\n", "fig = go.Figure()\n", "\n", "for V0 in np.linspace(1, 3, 6):\n", " system = simulate_experiment(V0, 30)\n", " pt.continuize(system, dt=0.03, inplace=True)\n", " rvw, s, t = system.balls[\"cue\"].history_cts.vectorize()\n", " xy = rvw[:, 0, :2]\n", "\n", " fig.add_trace(\n", " go.Scatter(\n", " x=xy[:, 0],\n", " y=xy[:, 1],\n", " mode=\"lines\",\n", " name=f\"Speed {V0}\",\n", " showlegend=True,\n", " )\n", " )\n", "\n", "fig.update_layout(\n", " title=\"Ball trajectories\",\n", " xaxis_title=\"X [m]\",\n", " yaxis_title=\"Y [m]\",\n", " yaxis_scaleanchor=\"x\",\n", " yaxis_scaleratio=1,\n", " width=600,\n", " xaxis=dict(range=[1.5, 4.5]),\n", " yaxis=dict(range=[1.5, 4.5]),\n", " template=\"presentation\",\n", ")\n", "fig.show()" ] }, { "cell_type": "markdown", "id": "c3899152", "metadata": {}, "source": [ "Harder shots follow the *tangent line* (aka the line perpendicular to the line connected the balls' centers during contact) for longer, but they all converge to the same outgoing angle." ] } ], "metadata": { "jupytext": { "cell_metadata_filter": "all", "notebook_metadata_filter": "all" }, "kernelspec": { "display_name": "pooltool-dev", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.0" } }, "nbformat": 4, "nbformat_minor": 5 }