.
شبیهسازی تخلیه آب از دو مخزن مخروط ناقص با پایتون
مقدمه
در این پروژه، فرآیند تخلیه آب از دو مخزن با هندسه مخروط ناقص (Truncated Cone) به کمک زبان برنامهنویسی Python شبیهسازی شده است
هدف اصلی این پروژه، بررسی تأثیر شکل هندسی و جهت قرارگیری مخزن بر سرعت تخلیه آب و مدتزمان خالی شدن آن است
در این شبیهسازی، دو مخزن با ابعاد و حجم کاملاً یکسان در نظر گرفته شدهاند. تفاوت اصلی آنها در جهت قرارگیری است؛ بهطوریکه یکی دارای سطح مقطع کوچک در پایین و دیگری دارای سطح مقطع بزرگ در پایین است
با استفاده از قوانین مکانیک سیالات و معادله تورچلی (Torricelli’s Law)، تغییرات سطح آب، سرعت خروج سیال و دبی تخلیه در طول زمان محاسبه و بهصورت انیمیشن سهبعدی نمایش داده میشوند
معرفی هندسه مخازن
هندسه هر دو مخزن از نوع مخروط ناقص است. این شکل از یک مخروط کامل با حذف قسمت بالایی آن به دست میآید
پارامترهای هندسی مخازن به شرح زیر هستند:
ارتفاع مخزن: 0.5 متر
شعاع قاعده بزرگ: 0.9 متر
شعاع قاعده کوچک: 0.05 متر
قطر خروجی: 0.05 متر
ضریب تخلیه: 0.62
شتاب گرانش: 9.81 متر بر مجذور ثانیه
در مخزن اول، قاعده کوچک در پایین و قاعده بزرگ در بالا قرار دارد
در مخزن دوم، جهت هندسه معکوس شده و قاعده بزرگ در پایین و قاعده کوچک در بالا قرار گرفته است
از آنجا که ابعاد هندسی هر دو مخزن یکسان است، حجم اولیه آب در آنها نیز برابر خواهد بود
مبانی فیزیکی و روابط حاکم
برای بررسی فرآیند تخلیه، از قانون تورچلی استفاده میکنیم. این قانون سرعت خروج سیال از یک روزنه را بر اساس ارتفاع ستون آب بالای خروجی تخمین میزند
۲.۱. محاسبه سرعت خروج آب
طبق قانون تورچلی، سرعت لحظهای خروج آب از روزنه برابر است با:
فرمول:
\[
v=\sqrt{2gh}
\]
در این رابطه:
(v): سرعت خروج آب بر حسب متر بر ثانیه
(g): شتاب گرانش
(h): ارتفاع سطح آب نسبت به مرکز خروجی
بر اساس این رابطه، هرچه ارتفاع آب بیشتر باشد، سرعت خروج سیال نیز بیشتر خواهد بود. با کاهش ارتفاع آب، سرعت خروج نیز کاهش پیدا میکند
۲.۲. محاسبه دبی خروجی
دبی حجمی جریان با استفاده از رابطه زیر محاسبه میشود:
فرمول:
\[
Q=C_d A_o\sqrt{2gh}
\]
که در آن:
(Q): دبی حجمی خروج آب
(C_d): ضریب تخلیه
(A_o): مساحت سطح مقطع روزنه خروجی
(h): ارتفاع لحظهای آب
مساحت روزنه خروجی از رابطه زیر به دست میآید:
فرمول:
\[
A_o=\frac{\pi d^2}{4}
\]
در این پروژه، برای در نظر گرفتن افتهای واقعی جریان از ضریب تخلیه استفاده شده است
۲.۳. تغییرات سطح آب در طول زمان
یکی از مهمترین بخشهای این شبیهسازی، محاسبه سرعت پایین آمدن سطح آب در مخزن است
با استفاده از قانون بقای جرم، تغییر حجم آب در واحد زمان برابر با دبی خروجی خواهد بود:
فرمول:
\[
\frac{dV}{dt}=-Q
\]
از طرف دیگر، تغییر حجم آب با تغییر ارتفاع سطح آن ارتباط دارد:
فرمول:
\[
\frac{dV}{dh}=A(h)
\]
که در آن (A(h)) مساحت سطح مقطع مخزن در ارتفاع مشخص است
با ترکیب این دو رابطه، معادله دیفرانسیل حاکم بر تخلیه به دست میآید:
فرمول:
\[
\frac{dh}{dt}=
-\frac{C_d A_o\sqrt{2gh}}{A(h)}
\]
این رابطه نشان میدهد که سرعت کاهش ارتفاع آب فقط به ارتفاع سطح آب وابسته نیست، بلکه شکل هندسی مخزن و مساحت سطح مقطع آن در هر ارتفاع نیز نقش مهمی دارند
مدلسازی هندسی مخازن
از آنجا که هندسه مخزن از نوع مخروط ناقص است، شعاع سطح مقطع آن با ارتفاع بهصورت خطی تغییر میکند
برای مخزن اول که قاعده کوچک در پایین قرار دارد، شعاع در ارتفاع h از رابطه زیر محاسبه میشود:
فرمول:
\[
r_1(h)=r+\frac{R-r}{H}h
\]
بنابراین مساحت سطح مقطع آن برابر است با:
فرمول:
\[
A_1(h)=\pi
\left(r+\frac{R-r}{H}h\right)^2
\]
برای مخزن دوم که قاعده بزرگ در پایین قرار دارد، رابطه شعاع به شکل زیر خواهد بود:
فرمول:
\[
r_2(h)=R-\frac{R-r}{H}h
\]
و مساحت سطح مقطع آن برابر است با:
فرمول:
\[
A_2(h)=\pi
\left(R-\frac{R-r}{H}h\right)^2
\]
با قرار دادن این روابط در معادله دیفرانسیل تخلیه، میتوان تغییرات ارتفاع آب را در هر دو مخزن بهصورت مستقل محاسبه کرد
محاسبه زمان تخلیه کامل
برای محاسبه زمان تخلیه کامل مخزن، معادله دیفرانسیل را بر حسب ارتفاع بازنویسی میکنیم:
فرمول:
\[
dt=
-\frac{A(h)}
{C_d A_o\sqrt{2gh}}dh
\]
با انتگرالگیری از ارتفاع اولیه تا صفر، زمان تخلیه کامل به دست میآید:
فرمول:
\[
t_d=
\frac{1}{C_d A_o\sqrt{2g}}
\int_0^H\frac{A(h)}{\sqrt{h}}dh
\]
این رابطه نشان میدهد که زمان تخلیه به توزیع مساحت سطح مقطع در ارتفاعهای مختلف وابسته است
از آنجا که تابع زیر انتگرال در نزدیکی ارتفاع صفر دارای تکینگی است، برای محاسبات عددی از تغییر متغیر زیر استفاده میکنیم:
فرمول:
\[
x=\sqrt{h}
\]
در نتیجه:
فرمول:
\[
h=x^2
\]
و رابطه زمان تخلیه به شکل زیر تبدیل میشود:
فرمول:
\[
t_d=
\frac{2}{C_d A_o\sqrt{2g}}
\int_0^{\sqrt{H}}A(x^2)dx
\]
در برنامه، مقدار این انتگرال با روش ذوزنقهای و به کمک کتابخانه NumPy محاسبه میشود
پیادهسازی با زبان Python
برای توسعه این پروژه از زبان برنامهنویسی Python و کتابخانههای علمی آن استفاده شده است
NumPy: برای محاسبات عددی، تعریف آرایهها و انجام انتگرالگیری عددی
Matplotlib: برای رسم نمودارها و ایجاد انیمیشن سهبعدی
Matplotlib Animation: برای بهروزرسانی پیوسته وضعیت مخازن در طول زمان
با استفاده از این ابزارها، مدل ریاضی به یک شبیهسازی بصری تبدیل شده است که امکان بررسی همزمان رفتار هر دو مخزن را فراهم میکند
قابلیتهای انیمیشن شبیهسازی
در این پروژه، علاوه بر محاسبات فیزیکی، یک محیط گرافیکی با سبک Cyber طراحی شده است
ویژگیهای اصلی انیمیشن عبارتاند از:
نمایش همزمان دو مخزن مخروط ناقص در محیط سهبعدی
نمایش سطح آب و تغییر پیوسته ارتفاع آن
شبیهسازی جریان خروجی آب از روزنه هر مخزن
نمایش ذرات متحرک برای قابل مشاهده کردن جریان خروجی
نمایش اطلاعات فیزیکی بهصورت زنده
رسم نمودار تغییرات ارتفاع آب بر حسب زمان
امکان توقف و ادامه انیمیشن
قابلیت شروع مجدد شبیهسازی
تنظیم سرعت اجرای انیمیشن
اطلاعاتی مانند زمان سپریشده، ارتفاع آب، سرعت خروج، دبی لحظهای و حجم باقیمانده آب در طول شبیهسازی بهروزرسانی میشوند
بررسی و تحلیل رفتار دو مخزن
یکی از اهداف مهم این پروژه، بررسی تأثیر جهت قرارگیری مخزن بر زمان تخلیه است
در مخزن اول، سطح مقطع نزدیک خروجی کوچکتر است. بنابراین در ارتفاعهای پایین، حجم کمتری از آب با هر واحد کاهش ارتفاع از مخزن خارج میشود
در مخزن دوم، سطح مقطع نزدیک خروجی بزرگتر است. در نتیجه برای کاهش یکسان ارتفاع آب، حجم بیشتری از سیال باید خارج شود
اگرچه سرعت خروج آب در هر دو مخزن در ارتفاع یکسان برابر خواهد بود، اما سرعت پایین آمدن سطح آب در آنها یکسان نیست
این تفاوت از معادله زیر قابل مشاهده است:
فرمول:
\[
\frac{dh}{dt}=
-\frac{Q}{A(h)}
\]
بنابراین حتی با وجود یکسان بودن ابعاد و حجم اولیه، جهت قرارگیری مخزن میتواند بر مدتزمان تخلیه کامل تأثیر بگذارد
محدودیتهای مدلسازی
این پروژه بر اساس مدل ایدهآل تخلیه سیال و قانون تورچلی توسعه داده شده است
در مدل فعلی، برخی پدیدههای پیچیده جریان بهصورت مستقیم شبیهسازی نشدهاند
از جمله این موارد میتوان به موارد زیر اشاره کرد:
-
تغییرات لحظهای ضریب تخلیه
-
آشفتگی و گردابههای جریان
-
افت انرژی ناشی از اصطکاک و اتصالات
-
اثرات دقیق هندسه روزنه و شکل جت خروجی
-
اندرکنش سهبعدی سیال با دیوارههای مخزن
همچنین قطر خروجی انتخابشده نسبت به شعاع قاعده کوچک، مقدار نسبتاً بزرگی دارد. بنابراین فرض روزنه کوچک و مدل شبهپایا ممکن است در این هندسه دقت محدودی داشته باشد
برای دستیابی به نتایج دقیقتر میتوان از روشهای پیشرفتهتر دینامیک سیالات محاسباتی (CFD) استفاده کرد
جمعبندی
در این پروژه، فرآیند تخلیه آب از دو مخزن مخروط ناقص با جهت قرارگیری متفاوت، با استفاده از قوانین مکانیک سیالات و زبان برنامهنویسی Python شبیهسازی شد
نتایج مدل نشان میدهند که شکل هندسی و نحوه قرارگیری مخزن میتوانند تأثیر قابلتوجهی بر رفتار تخلیه داشته باشند
این پروژه نمونهای از ترکیب دانش مهندسی مکانیک، ریاضیات، معادلات دیفرانسیل و برنامهنویسی برای حل و تحلیل مسائل فیزیکی است
چنین شبیهسازیهایی علاوه بر کمک به درک بهتر مفاهیم تئوری، امکان بررسی رفتار سیستمهای مهندسی را در یک محیط بصری و تعاملی فراهم میکنند
RETROM | Engineering Beyond Limits
طراحی، شبیهسازی و توسعه راهکارهای مهندسی با ترکیب مکانیک، الکترونیک و برنامهنویسی
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.widgets import Button, Slider
from mpl_toolkits.mplot3d import Axes3D # noqa: F401
# ============================================================
# 1. PHYSICAL PARAMETERS
# ============================================================
H = 0.5 # Tank height (m)
R = 0.9 # Larger radius (m)
r = 0.05 # Smaller radius (m)
d = 0.05 # Outlet diameter (m)
Cd = 0.62 # Discharge coefficient
g = 9.81 # Gravity (m/s^2)
outlet_area = np.pi * d**2 / 4
k = (R - r) / H
POINTS = 2500
# ============================================================
# 2. TANK GEOMETRY
# ============================================================
def radius_normal(h):
"""Small base at the bottom."""
return r + k * h
def radius_inverted(h):
"""Large base at the bottom."""
return R - k * h
def area_normal(h):
return np.pi * radius_normal(h)**2
def area_inverted(h):
return np.pi * radius_inverted(h)**2
# ============================================================
# 3. NUMERICAL SIMULATION
# ============================================================
def simulate(area_function, points=POINTS):
# Substitution: h = x^2
x = np.linspace(0, np.sqrt(H), points)
h = x**2
# Integrand after substitution
f = (
2 * area_function(h)
/ (Cd * outlet_area * np.sqrt(2 * g))
)
dx = x[1] - x[0]
# Cumulative integral: time required to drain
# from height h down to zero
cumulative_time = np.zeros(points)
for i in range(1, points):
dt = (f[i - 1] + f[i]) * dx / 2
cumulative_time[i] = (
cumulative_time[i - 1] + dt
)
total_time = cumulative_time[-1]
# Convert to elapsed time, starting at full tank
elapsed_time = total_time - cumulative_time[::-1]
height = h[::-1]
return elapsed_time, height, total_time
# Simulate both tanks
time_1, height_1, total_1 = simulate(area_normal)
time_2, height_2, total_2 = simulate(area_inverted)
max_time = max(total_1, total_2)
# ============================================================
# 4. VOLUME CALCULATIONS
# ============================================================
def remaining_volume(height, bottom_radius, slope):
# Exact volume of a partial frustum
current_radius = bottom_radius + slope * height
volume = (
np.pi * height / 3
* (
bottom_radius**2
+ bottom_radius * current_radius
+ current_radius**2
)
)
return volume
total_volume = np.pi * H / 3 * (
R**2 + R * r + r**2
)
# ============================================================
# 5. CYBER COLOR THEME
# ============================================================
BG = "#07111F"
PANEL = "#0B1C2D"
CYAN = "#00E5FF"
BLUE = "#168BFF"
PURPLE = "#B45CFF"
GREEN = "#00F5A0"
WHITE = "#E5F7FF"
MUTED = "#7396AD"
ORANGE = "#FFB84D"
# ============================================================
# 6. FIGURE AND LAYOUT
# ============================================================
plt.rcParams["figure.facecolor"] = BG
plt.rcParams["axes.facecolor"] = PANEL
plt.rcParams["text.color"] = WHITE
plt.rcParams["axes.labelcolor"] = MUTED
plt.rcParams["xtick.color"] = MUTED
plt.rcParams["ytick.color"] = MUTED
plt.rcParams["font.size"] = 9
fig = plt.figure(figsize=(15, 10))
fig.canvas.manager.set_window_title(
"RETROM | Frustum Drainage Simulator"
)
fig.suptitle(
"RETROM // FRUSTUM DRAINAGE SIMULATOR",
color=CYAN,
fontsize=17,
fontweight="bold",
y=0.97
)
# Two 3D tanks on top
ax1 = fig.add_subplot(2, 2, 1, projection="3d")
ax2 = fig.add_subplot(2, 2, 2, projection="3d")
# Graph across the bottom
ax_graph = fig.add_subplot(2, 1, 2)
# Leave space for controls
plt.subplots_adjust(
left=0.06,
right=0.96,
top=0.90,
bottom=0.22,
hspace=0.30,
wspace=0.12
)
# ============================================================
# 7. TANK DRAWING
# ============================================================
theta = np.linspace(0, 2 * np.pi, 60)
z_wall = np.linspace(0, H, 35)
THETA, Z = np.meshgrid(theta, z_wall)
def draw_tank(ax, inverted=False):
if inverted:
rad = radius_inverted(Z)
title = "TANK B | LARGE BASE DOWN"
color = PURPLE
else:
rad = radius_normal(Z)
title = "TANK A | SMALL BASE DOWN"
color = CYAN
X = rad * np.cos(THETA)
Y = rad * np.sin(THETA)
# Transparent tank wall
ax.plot_surface(
X, Y, Z,
color=color,
alpha=0.12,
edgecolor=color,
linewidth=0.25,
rstride=2,
cstride=3
)
# Top and bottom circular rims
for z_value in [0, H]:
if inverted:
rad_value = radius_inverted(z_value)
else:
rad_value = radius_normal(z_value)
circle_x = rad_value * np.cos(theta)
circle_y = rad_value * np.sin(theta)
ax.plot(
circle_x,
circle_y,
np.full_like(theta, z_value),
color=color,
linewidth=1.5
)
# Center outlet marker
ax.scatter(
[0], [0], [0],
color=ORANGE,
s=35
)
ax.set_xlim(-R * 1.25, R * 1.25)
ax.set_ylim(-R * 1.25, R * 1.25)
ax.set_zlim(-0.35, H * 1.12)
ax.set_box_aspect((1, 1, 1.2))
ax.set_title(
title,
color=color,
fontsize=11,
fontweight="bold",
pad=12
)
ax.set_xlabel("X (m)", labelpad=2)
ax.set_ylabel("Y (m)", labelpad=2)
ax.set_zlabel("Height (m)", labelpad=2)
ax.tick_params(colors=MUTED, labelsize=7)
ax.view_init(elev=23, azim=-55)
# Dark panes
for axis in [ax.xaxis, ax.yaxis, ax.zaxis]:
axis.pane.set_facecolor(BG)
axis.pane.set_edgecolor(MUTED)
ax.grid(color="#244258", alpha=0.4)
return color
color_1 = draw_tank(ax1, inverted=False)
color_2 = draw_tank(ax2, inverted=True)
# ============================================================
# 8. WATER GEOMETRY
# ============================================================
def create_water(ax, level, inverted=False):
if level <= 0.0001:
return []
z = np.linspace(0, level, 25)
th = np.linspace(0, 2 * np.pi, 60)
TH, ZZ = np.meshgrid(th, z)
if inverted:
rad = radius_inverted(ZZ)
bottom_radius = R
slope = -k
else:
rad = radius_normal(ZZ)
bottom_radius = r
slope = k
X = rad * np.cos(TH)
Y = rad * np.sin(TH)
water_artists = []
# Water side surface
side = ax.plot_surface(
X, Y, ZZ,
color=BLUE,
alpha=0.48,
edgecolor="#38CFFF",
linewidth=0.15,
shade=True
)
water_artists.append(side)
# Top water surface
radial = np.linspace(0, 1, 16)
TH2, RR = np.meshgrid(th, radial)
top_radius = bottom_radius + slope * level
X_top = top_radius * RR * np.cos(TH2)
Y_top = top_radius * RR * np.sin(TH2)
Z_top = np.full_like(X_top, level)
top = ax.plot_surface(
X_top, Y_top, Z_top,
color=CYAN,
alpha=0.70,
edgecolor="#A5F7FF",
linewidth=0.15,
shade=True
)
water_artists.append(top)
return water_artists
# ============================================================
# 9. OUTLET FLOW
# ============================================================
# Animated particles below the outlet
particle_count = 18
particle_phase = np.linspace(
0, 1, particle_count, endpoint=False
)
jet_1, = ax1.plot(
[0, 0], [0, 0], [0, -0.3],
color=CYAN,
linewidth=2.5,
alpha=0.8
)
jet_2, = ax2.plot(
[0, 0], [0, 0], [0, -0.3],
color=PURPLE,
linewidth=2.5,
alpha=0.8
)
particles_1 = ax1.scatter(
np.zeros(particle_count),
np.zeros(particle_count),
np.zeros(particle_count),
color=CYAN,
s=12,
alpha=0.9
)
particles_2 = ax2.scatter(
np.zeros(particle_count),
np.zeros(particle_count),
np.zeros(particle_count),
color=PURPLE,
s=12,
alpha=0.9
)
# ============================================================
# 10. INFORMATION PANELS
# ============================================================
info_1 = ax1.text2D(
0.03, 0.96, "",
transform=ax1.transAxes,
color=CYAN,
fontsize=8,
verticalalignment="top"
)
info_2 = ax2.text2D(
0.03, 0.96, "",
transform=ax2.transAxes,
color=PURPLE,
fontsize=8,
verticalalignment="top"
)
# ============================================================
# 11. LIVE GRAPH
# ============================================================
line_1, = ax_graph.plot(
time_1, height_1,
color=CYAN,
linewidth=2.5,
label="Tank A - Small base down"
)
line_2, = ax_graph.plot(
time_2, height_2,
color=PURPLE,
linewidth=2.5,
label="Tank B - Large base down"
)
cursor_1 = ax_graph.axvline(
0, color=CYAN, alpha=0.5, linestyle="--"
)
cursor_2 = ax_graph.axvline(
0, color=PURPLE, alpha=0.5, linestyle=":"
)
ax_graph.set_title(
"WATER HEIGHT vs ELAPSED TIME",
color=WHITE,
fontsize=11,
fontweight="bold"
)
ax_graph.set_xlabel("Elapsed time (s)")
ax_graph.set_ylabel("Water height (m)")
ax_graph.set_xlim(0, max_time * 1.03)
ax_graph.set_ylim(0, H * 1.12)
ax_graph.legend(
facecolor=PANEL,
edgecolor=MUTED,
labelcolor=WHITE,
loc="upper right"
)
ax_graph.grid(
color="#31516A",
alpha=0.35,
linestyle="--"
)
# ============================================================
# 12. ANIMATION STATE
# ============================================================
FRAME_COUNT = 300
current_frame = 0
is_running = True
animation_speed = 1.0
water_artists_1 = []
water_artists_2 = []
def clear_water():
global water_artists_1, water_artists_2
for artist in water_artists_1 + water_artists_2:
artist.remove()
water_artists_1 = []
water_artists_2 = []
# ============================================================
# 13. UPDATE FUNCTION
# ============================================================
def update(frame):
global current_frame
global water_artists_1, water_artists_2
current_frame = frame
# Current simulation time
elapsed = max_time * frame / FRAME_COUNT
# Each tank stops when it becomes empty
elapsed_1 = min(elapsed, total_1)
elapsed_2 = min(elapsed, total_2)
# Current water heights
level_1 = np.interp(
elapsed_1, time_1, height_1
)
level_2 = np.interp(
elapsed_2, time_2, height_2
)
# Clear previous water surfaces
clear_water()
# Draw new water surfaces
water_artists_1 = create_water(
ax1, level_1, inverted=False
)
water_artists_2 = create_water(
ax2, level_2, inverted=True
)
# --------------------------------------------------------
# Flow velocity and flow rate
# --------------------------------------------------------
velocity_1 = np.sqrt(2 * g * level_1)
velocity_2 = np.sqrt(2 * g * level_2)
flow_1 = Cd * outlet_area * velocity_1
flow_2 = Cd * outlet_area * velocity_2
# --------------------------------------------------------
# Remaining volumes
# --------------------------------------------------------
volume_1 = remaining_volume(
level_1, r, k
)
volume_2 = remaining_volume(
level_2, R, -k
)
percent_1 = 100 * volume_1 / total_volume
percent_2 = 100 * volume_2 / total_volume
# --------------------------------------------------------
# Information text
# --------------------------------------------------------
info_1.set_text(
f"TIME: {elapsed:.1f} s\n"
f"HEIGHT: {level_1:.3f} m\n"
f"VELOCITY: {velocity_1:.3f} m/s\n"
f"FLOW: {flow_1 * 1000:.2f} L/s\n"
f"REMAINING: {percent_1:.1f}%"
)
info_2.set_text(
f"TIME: {elapsed:.1f} s\n"
f"HEIGHT: {level_2:.3f} m\n"
f"VELOCITY: {velocity_2:.3f} m/s\n"
f"FLOW: {flow_2 * 1000:.2f} L/s\n"
f"REMAINING: {percent_2:.1f}%"
)
# --------------------------------------------------------
# Animated outlet jet
# --------------------------------------------------------
def update_jet(
ax, jet, particles, velocity, frame, color
):
if velocity <= 0.001:
jet.set_data_3d(
[0, 0], [0, 0], [0, 0]
)
particles._offsets3d = (
np.zeros(particle_count),
np.zeros(particle_count),
np.zeros(particle_count)
)
return
# Jet length grows with velocity
jet_length = min(0.12 + velocity * 0.045, 0.32)
jet.set_data_3d(
[0, 0],
[0, 0],
[0, -jet_length]
)
# Moving particles
phase = (
particle_phase + frame * 0.045 * animation_speed
) % 1
particle_z = -phase * jet_length
particles._offsets3d = (
np.zeros(particle_count),
np.zeros(particle_count),
particle_z
)
update_jet(
ax1, jet_1, particles_1,
velocity_1, frame, CYAN
)
update_jet(
ax2, jet_2, particles_2,
velocity_2, frame, PURPLE
)
# --------------------------------------------------------
# Graph cursors
# --------------------------------------------------------
cursor_1.set_xdata([elapsed_1, elapsed_1])
cursor_2.set_xdata([elapsed_2, elapsed_2])
# --------------------------------------------------------
# Figure title
# --------------------------------------------------------
fig.suptitle(
f"RETROM // FRUSTUM DRAINAGE SIMULATOR"
f" SIMULATION TIME: {elapsed:.1f} s",
color=CYAN,
fontsize=15,
fontweight="bold"
)
return (
water_artists_1
+ water_artists_2
+ [
info_1, info_2,
jet_1, jet_2,
particles_1, particles_2,
cursor_1, cursor_2
]
)
# ============================================================
# 14. CONTROL BUTTONS
# ============================================================
# Pause / Resume
ax_pause = fig.add_axes([0.30, 0.09, 0.12, 0.055])
btn_pause = Button(
ax_pause, "PAUSE",
color="#16334A",
hovercolor="#245875"
)
# Reset
ax_reset = fig.add_axes([0.45, 0.09, 0.12, 0.055])
btn_reset = Button(
ax_reset, "RESTART",
color="#16334A",
hovercolor="#245875"
)
# Speed slider
ax_speed = fig.add_axes([0.66, 0.105, 0.22, 0.025])
speed_slider = Slider(
ax_speed,
"SPEED",
0.25,
3.0,
valinit=1.0,
color=CYAN
)
def toggle_pause(event):
global is_running
if is_running:
animation.event_source.stop()
btn_pause.label.set_text("RESUME")
is_running = False
else:
animation.event_source.start()
btn_pause.label.set_text("PAUSE")
is_running = True
def restart(event):
global current_frame
current_frame = 0
animation.event_source.stop()
update(0)
fig.canvas.draw_idle()
if is_running:
animation.event_source.start()
def change_speed(value):
global animation_speed
animation_speed = value
animation.event_source.interval = max(
10, int(35 / value)
)
btn_pause.on_clicked(toggle_pause)
btn_reset.on_clicked(restart)
speed_slider.on_changed(change_speed)
# ============================================================
# 15. START ANIMATION
# ============================================================
animation = FuncAnimation(
fig,
update,
frames=range(FRAME_COUNT + 1),
interval=35,
repeat=False,
blit=False,
cache_frame_data=False
)
# Initial frame
update(0)
# Print results
print("=" * 45)
print(" FRUSTUM DRAINAGE SIMULATION")
print("=" * 45)
print(f"Initial volume: {total_volume:.4f} m^3")
print(f"Tank A drainage time: {total_1:.2f} s")
print(f"Tank B drainage time: {total_2:.2f} s")
if total_1 < total_2:
print("Tank A drains first.")
else:
print("Tank B drains first.")
print("=" * 45)
plt.show()
[v=\sqrt{2gh}]
