Fizik, Hareket, Türevler, Grafikler
Son gönderim tarihi: 2 Haziran Çarşamba, 23:59
Gönderim şekli: FIZ220_Odev_03Grup#.ipynb isimli jupyter ipynb formatında dosyayı (ziplenmiş olarak) ödev sayfasından göndermek suretiyle
Gönderecek kişi: Grup temsilcisi
Dr. Emre S. Taşcı, emre.tasci@hacettepe.edu.tr
Fizik Mühendisliği Bölümü
Hacettepe Üniversitesi
$h = 30\text{ m}$ yüksekliğinden, $m = 1\text{ kg}$ ağırlığında bir top bırakılıyor. Top yere her çarptığında mekanik enerjisinin $\frac{1}{4}$ kadarı sürtünmeye gidiyor (yani $i.$ hareketi sırasında $E_i = \tfrac{3}{4}E_{i-1}$ şeklinde).
10. kez yere çarpıncaya kadar:
sonuclar
matrisi oluşturup:komutlarıyla çizdirebilirsiniz)
$\newcommand{\unit}[1]{\,\text{#1}} \newcommand{\dydx}[2]{\frac{\text{d}#1}{\text{d}#2}}$ Bu soruyu önce elimizle çözmeye başlayalım. Bize $h_0 = 30\unit{m}$ olarak verilmiş. Bu durumda düşüş süresini şu şekilde hesaplarız: $$h_0 = \tfrac{1}{2}g t_0^2\Rightarrow t_0 =\sqrt{\frac{2h_0}{g}}$$
Cismin başlangıç enerjisini $E_0$ ile gösterelim: $$E_0 = mgh_0$$
Cisim yere ($h=0$) varınca enerjisi $\tfrac{3}{4}$'üne düşecek, bu enerjiyi de $E_1$ ile gösterelim: $$E_1 = \tfrac{3}{4}E_0$$
Bu aşamadaki sorumuz şu olur: $E_1$ başlangıç -kinetik- enerjili bir cisim ne kadar yükselir? Bu maksimum ulaşacağı yüksekliğe $h_1$ dersek tabii ki: $$E_1 = mgh_1$$ olana kadar buluruz. Buradan da $h_1$'i çekersek: $$h_1 = \frac{E_1}{mg}$$ olarak buluruz (yükseklikle potansiyel enerji arasındaki ilişkinin doğrusal olmasından dolayı doğrudan $h_1 = \tfrac{3}{4} h_0$ da yazabilirdik ama bu şekilde daha açıklayıcı 8).
Peki yerden ($h=0$) $h_1$ yüksekliğine ulaşmasına kadar geçen süre? Bu süreyi de $t_1'$ ile gösterelim: $$h_1 = \tfrac{1}{2}g t_1'^2\Rightarrow t_1' =\sqrt{\frac{2h_1}{g}}$$
Sorumuzdaki değerlerle buraya kadar olan kısmı çözersek:
import numpy as np
g = 9.8 # m/s^2
m = 1 # kg
h0 = 30 # m
t0 = np.sqrt(2*h0/g) # s
E0 = m*g*h0 # J
print("h0: {:6.3f}m | t0 : {:6.3f}s | E0: {:6.2f}J".format(h0,t0,E0))
# ------------------------
E1 = 3/4 * E0
h1 = E1 / (m*g)
t1p = np.sqrt(2*h1/g)
print("h1: {:6.3f}m | t1': {:6.3f}s | E1: {:6.2f}J".format(h1,t1p,E1))
h0: 30.000m | t0 : 2.474s | E0: 294.00J h1: 22.500m | t1': 2.143s | E1: 220.50J
$t = [0,t_0]$ aralığındaki yükseklik değerlerini hesaplayalım. $$y(t) = h_0 + \tfrac{1}{2}at^2 = h_0 + \tfrac{1}{2}(-g)t^2 = h_0 - \tfrac{1}{2}gt^2$$ olduğundan, $[0,t_0]$ aralığını $N=20$ parçaya bölüp, her bir noktasında formülü uygulayalım:
N = 20
tler_0 = np.linspace(0,t0,N)
yler_0 = h0 - 0.5*g*tler_0**2
for i in range(N):
print("{:.3f}s : {:.3f}m".format(tler_0[i],yler_0[i]))
0.000s : 30.000m 0.130s : 29.917m 0.260s : 29.668m 0.391s : 29.252m 0.521s : 28.670m 0.651s : 27.922m 0.781s : 27.008m 0.912s : 25.928m 1.042s : 24.681m 1.172s : 23.269m 1.302s : 21.690m 1.433s : 19.945m 1.563s : 18.033m 1.693s : 15.956m 1.823s : 13.712m 1.953s : 11.302m 2.084s : 8.726m 2.214s : 5.983m 2.344s : 3.075m 2.474s : 0.000m
Buraya kadar olan yükseklik-zaman grafiğini çizdirmek zaten çocuk oyuncağı!
import matplotlib.pyplot as plt
plt.plot(tler_0,yler_0,"o-b")
plt.show()
Kafamızı ve fiziği kullanma vakti geldi. İkinci kısım olan yükselişte bildiklerimiz:
Uçuş süresi aralığını yine $N$ parçaya bölelim. Yükselmeye başladığı andan geçen zamanı $t'$ ile gösterirsek:
$$y(t') = v_1 t - \tfrac{1}{2}gt^2$$$v_1$ yükselmeye başladığındaki hızı. Bunu da potansiyel enerjideki azalmanın kinetik enerjiye gittiğinden hesaplayabiliriz. Korunumlu bir sistemde bu hız çarpış hızına eşit olacaktı ama çarpma anında enerjisinin $\tfrac{3}{4}$'ü yiteceğinden: $$E_1 = \tfrac{3}{4} E_0= \tfrac{3}{4} mgh_0 = \tfrac{1}{2} m v_1^2\Rightarrow \boxed{v_1 = \sqrt{\tfrac{3}{4}\times 2 g h_0}}$$
tler_1 = np.linspace(0,t1p,N)
v1 = np.sqrt(3/4 * 2*g*h0)
yler_1 = v1*tler_1-0.5*g*tler_1**2
plt.plot(tler_1,yler_1,"o-b")
plt.show()
Fiziği kullanarak gayet güzel bir şekilde bulduk ama bunun yanında kafamızı da kullanarak daha da güzel bir şekilde bulabilirdik:
Bir topu serbest düşüşle -korunumlu bir sistemde- bıraktığımızda topun sonsuza kadar yerle bıraktığımız yükseklik arasında sekeceğini biliyoruz. Derslerde duyageldiğimiz ama doğrusu pek de anlamı üzerinde durmadığımız harika bir gerçek var (enerjinin korunumu):
bunun tersi de doğrudur:
Bu muhteşem deyişin başka varyantları vardır:
Hayatlarımızı muazzam bir şekilde kolaylaştıran bu çıkarım yine harika bir bilim insanı olan Emmy Noether tarafından 1915 yılında yapılmıştır, Noether Teoremi adıyla anılır (simetri müthiş bir olgu arkadaşlar! Doğa işini biliyor! 8).
Peki bunun bizim durumumuzla ne ilgisi var? Enerji korunuyor, değil mi? Evet. O halde zamana göre simetrimiz var. Yani biz -korunumlu sistemde- zıplayıp duran topumuzu videoya çeksek, sonra o videoyu tersten oynatsak, bunun tersten oynatıldığının farkına varamayız.
Bu demektir ki, topun $v_1$ ilk hızıyla yukarı atıldıktan sonra $h_1$ yüksekliğine ulaşıncaya kadar olan hareketini incelemek yerine, $h_1$ yüksekliğinden serbest düşüşe bırakıldığındaki hareketini kolayca hesaplayıp, bunu tersinden oynatabiliriz (yükselmesi için geçen $t_1'$ süresinin düşerken geçen süreye eşit olduğunu biliyoruz): $$y(t') = h_1 - \tfrac{1}{2}gt'^2$$
tler_1 = np.linspace(0,t1p,N)
yler_1_yukselis = h1 - 0.5*g*tler_1**2
#yler_1 = yler_1[::-1]
plt.plot(tler_1,yler_1_yukselis,"x-r")
plt.show()
Tersine çevirmek için Python dünden razı, sondan başlayıp (-1), başa doğru (0), geriye doğru birer birer (-1) alacağız. Önce normal bir listeyle gösterelim:
normal_liste = np.array([0,1,2,3,4,5])
print(normal_liste)
print(normal_liste[-1::-1])
[0 1 2 3 4 5] [5 4 3 2 1 0]
burada bitiş parametresi olan orta parametreyi pas geçtiğimize dikkat edin -- eğer "0" demiş olsaydık "0'a kadar (0 hariç)" alacaktı, o yüzden boş bırakıp "gittiği yere kadar" demiş olduk -- daha fazla detay için bkz. ilk dersimizin "Liste elemanlarına ulaşma" bölümünün sonundaki örnek ;).
Aynı derste gördüğümüz üzere, baştan sona (/sondan başa) demek için de aralık tanımlarını boş bırakabiliyoruz:
print(normal_liste[::-1])
[5 4 3 2 1 0]
Bu numarayı bizim yüksekliklerin dizisini tersine çevirmede kullanırsak:
tler_1 = np.linspace(0,t1p,N)
yler_1_yukselis = h1 - 0.5*g*tler_1**2
yler_1_yukselis_tersten = yler_1_yukselis[::-1]
plt.plot(tler_1,yler_1_yukselis_tersten,"x-r")
plt.show()
İlk yaklaşımla çıkardığımız grafiğimizi (mavi olan) andırıyor, değil mi? Üst üste bindirip bir kontrol edelim bakalım:
tler_1 = np.linspace(0,t1p,N)
v1 = np.sqrt(3/4 * 2*g*h0)
yler_1 = v1*tler_1-0.5*g*tler_1**2
yler_1_yukselis = h1 - 0.5*g*tler_1**2
yler_1_yukselis_tersten = yler_1_yukselis[::-1]
plt.plot(tler_1,yler_1,"o-b")
plt.plot(tler_1,yler_1_yukselis_tersten,"x-r")
plt.show()
Ta-daaaaa! 8) (Alkışlar size!)
Artık yapmamız gereken şey belli: $h_1$'den serbest düşürüp, çıkan değerlerin yanına ayna tutmak. Şöyle bir şey mesela:
tler_1 = np.linspace(0,t1p,N)
yler_1_dusus = h1 - 0.5*g*tler_1**2
yler_1_dusus_tersten = yler_1_dusus[:0:-1]
# Peki burada niye "0"i aldik? Ilk bilen 5 kisiye bonus puan var!
# (Dersimizin sayfasindaki formu kullanin)
# Yukselis verisiyle dusus verisini birlestirelim
yler_1 = np.concatenate([yler_1_dusus_tersten,yler_1_dusus])
# tler de iki katina cikti
tler_1 = np.concatenate([tler_1,tler_1[-1]+tler_1[1::]])
# Bu ustteki satiri da bonus sorusunda aciklayin
#print(tler_1)
#print(yler_1)
plt.plot(tler_1,yler_1,"o-b")
plt.show()
Elimizdeki ilk düşüş verileri ile, çarptıktan sonra yükselip düşüş verisini birleştirelim:
tler = np.concatenate([tler_0,tler_0[-1]+tler_1[1:]])
yler = np.concatenate([yler_0,yler_1[1:]])
# Bonusa bu ustteki satirlarin aciklamasi da dahil oldu
plt.plot(tler,yler,"o-b")
plt.show()
Bir sonraki uçuş parametreleri de ($h_2, E_2, t_2$,tler_2
,yler_2
) aslında biraz önce 0 verilerini kullanarak nasıl 1'in verilerini bulduysak, aynı yöntemle 1'den çıkarılacak. Bunu da 10 kere yapmamız isteniyor, bilgisayar da for
döngüsü ile bunu yapmaya dünden razı. O halde yukarıda yaptıklarımızı bir for döngüsü içinde toplayalım, şık olsun diye de hesaplarımızı fonksiyonlarla yaptıralım:
import numpy as np
import matplotlib.pyplot as plt
g = 9.8 # m/s^2
h = 30 # m
m = 1 # kg
E = m*g*h
# her bir dusus/yukselis suresinin
# kac adimda hesaplanacagi
N = 200
def ucus_suresi(h):
# h yuksekliginden serbest birakilan
# bir cismin h = 0 mesafesine dusene
# kadar gecen sureyi hesaplar
# h = 0.5*g*t**2 -> t = sqrt(2h/g)
return np.sqrt(2*h/g)
def yukseklik(h,t):
# h yuksekliginden serbest birakilan
# bir cismin t anindaki konumunu hesaplar
# y = h - 0.5*g*t**2
return (h - 0.5*g*t**2)
tler = []
yler = []
# Ilk dusus
tp = ucus_suresi(h)
tler_i = np.linspace(0,tp,N)
yler_i = yukseklik(h,tler_i)
tler = np.concatenate([tler,tler_i])
yler = np.concatenate([yler,yler_i])
for i in range(9):
h = 3/4 * h
tp = ucus_suresi(h)
tler_i = np.linspace(0,tp,N)
yler_i = yukseklik(h,tler_i)
yler = np.concatenate([yler,yler_i[:0:-1],yler_i])
tler = np.concatenate([tler,tler[-1]+tler_i,tler[-1]+tler_i[-1]+tler_i[1::]])
plt.plot(tler,yler,".b-")
plt.show()
Artık elimizde belli aralıklarda konumlar olduğuna göre, türevlerini kolayca alabiliriz. İlk dört konum değerini listeleyelim:
for i in range(4):
print("t={:.3f}s | y={:.3f}m".format(tler[i],yler[i]))
t=0.000s | y=30.000m t=0.012s | y=29.999m t=0.025s | y=29.997m t=0.037s | y=29.993m
Derste gördüğümüz türev formülünden, belli bir $t_i$ anındaki konumun türevi: $$\left.\dydx{y}{t}\right|_{t=t_i}=\frac{y(t_{i+1}) - y(t_{i-1})}{t_{i+1}-t_{i-1}}$$
Örneğin, $t=0.25\unit{s}$ anındaki hızı: $$v(t=0.25\unit{s}) = \left.\dydx{y}{t}\right|_{t=0.25\unit{s}}= \frac{29.993 - 29.999}{0.037-0.012}\unit{m/s}=-0.24\unit{m/s}$$ olarak hesaplarız.
Bunu bilgisayarda yaptırmak daha bile kolay!
vler = []
vtler = []
for i in range(1,yler.size-1):
delta_t = tler[i+1] - tler[i-1]
v_i = (yler[i+1] - yler[i-1]) / delta_t
vler.append(v_i)
vtler.append(tler[i])
plt.plot(vtler,vler,".r-")
plt.show()
Şu anda elimizde hız & zaman değerleri var, ivme isteniyor... O halde ne duruyoruz?
alar = []
atler = []
for i in range(1,len(vler)-1):
delta_t = vtler[i+1] - vtler[i-1]
a_i = (vler[i+1] - vler[i-1]) / delta_t
alar.append(a_i)
atler.append(vtler[i])
alar = np.array(alar)
atler = np.array(atler)
plt.plot(atler,alar,".g-")
plt.ylim(-10.2,-7)
plt.yticks(np.arange(-7,-10.2,-0.2))
plt.show()
(Bonuslar için bir soru daha: $a=-9.8\unit{m/s}^2$ değerleri tamam, beklenen değerler, peki o aralardaki fırlama değerleri nereden geliyor? Peki onların değerini bilgisayar kullanmadan (grafikten de bakmadan) tahmin edebilir misiniz?)
Eşdeğer iki top, eşzamanlı olarak şekildeki gibi iki rampadan bırakılıyorlar (ramplarda sürtünme kuvvetinin ihmal edilebildiğini varsayıp, topların mekanik enerjilerinin süreç boyunca birbirlerine eşit olduğuna dikkat edin):
(Rampaların en alt noktalarının aynı seviyede olduğunu düşünebilirsiniz - başlangıç ve bitiş yükseklikleri de aynı yüksekliktedir)
Topların kütlesini 1 kg ve karelerin kenarını 1 metre alarak:
grafiklerini çizdirin.
(rampaların sonundaki kinetik enerjilerinin, dolayısıyla hızlarının eşit olacağına dikkat edin! ;)
Yüksekliklerle potansiyel enerjiler arasında doğrusal bir ilişki olduğunu biliyoruz, o halde işe yükseklikleri tanımlayarak başlayalım:
# Kirmizi yolun degerleri
y1 = np.array([4,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,3])
# Mavi yolun degerleri
y2 = np.array([4,3.5,3,3,3,3,3,3,3,3,3,0,0,1,2,3,3,3])
x = np.arange(0,18)
plt.plot(x,y1,"r-")
plt.plot(x,y2,"b-")
plt.xticks(x)
plt.grid(True)
plt.show()
Yükseklik değiştikçe, potansiyel enerji de değişiyor. (Korunumlu bir sistemde) Potansiyel enerjideki değişim, kinetik enerjideki değişimin tersine eşittir (ki bu sayede toplam enerji korunur): $$-\Delta U = \Delta K$$
Bunun çıkarımı da hayli basit ve doğrudandır: $$ \begin{align*} E_i &= E_f\\ U_i + K_i &= U_f + K_f\\ U_i -U_f &= K_f - K_i\\ -(U_f - U_i) &= K_f - K_i\\ \Rightarrow -\Delta U &= \Delta K \end{align*}$$
Yani toplarımızın $y_{i}$ yüksekliğinden $y_{i+1}$ yüksekliğine gittiğinde potansiyel enerjileri de buna bağlı olarak $\Delta U = mg(y_{i+1} - y_{i})$ kadar değişecek, bu da kinetik enerjideki değişimin $\Delta K = -\Delta U = mg(y_{i} - y_{i+1})$ miktarında değişeceğini gösterecek.
Örneğin cismimiz $y_{i-1} = 4\unit{m}$ yükseklikten $y_{i} = 3\unit{m}$ yüksekliğe inmiş olsun. Bu durumda potansiyel enerjisindeki değişim: $\Delta U = mg\Delta h=(1\unit{kg})(9.8\unit{m/s}^2)(3\unit{m}-4\unit{m}) = -9.8\unit{J}$ kadar değişmiş, yani $9.8\unit{J}$ kadar azalmış olacak (sürpriz yok: cisim aşağı indikçe potansiyel enerjisi de o oranda azalır). Sistem korunuyorsa, kinetik enerji de bu kadar artmış olacak: $\Delta K = 9.8\unit{J}$. $y_{i-1}$ konumundaki hızı $v_{i-1}$ olsun, $y_{i}$ konumuna geldiğindeki hızını, kinetik enerjideki değişimden buluruz: $$\Delta K = K_{i} - K_{i-1} = \tfrac{1}{2}m v_{i}^2 - \tfrac{1}{2}m v_{i-1}^2$$
$$v_{i}^2 = v_{i-1}^2 + \frac{2\Delta K}{m}$$$$\Rightarrow \boxed{v_{i} = \sqrt{v_{i-1}^2 + \frac{2\Delta K}{m}}}$$Elimizde yükseklikler olduğuna göre, onları $mg$ ile çarparak potansiyel enerjileri, potansiyel enerjilerdeki değişimleri hesaplayarak da kinetik enerjilerdeki değişimi bulabilir, kinetik enerjilerdeki değişimlerden de hızların gelişimini hesaplayabiliriz:
m = 1 # kg
g = 9.8 # m/s^2
Pot_E1 = m*g*y1
Pot_E2 = m*g*y2
# baslangic hizlarini sifir aliyoruz
v1 = [0]
v2 = [0]
N = x.size
for i in range(1,N):
Delta_Kin_E1 = -(Pot_E1[i] - Pot_E1[i-1])
Delta_Kin_E2 = -(Pot_E2[i] - Pot_E2[i-1])
v1.append(np.sqrt(v1[i-1]**2 + 2*Delta_Kin_E1/m))
v2.append(np.sqrt(v2[i-1]**2 + 2*Delta_Kin_E2/m))
plt.plot(x,v1,"ro-")
plt.plot(x,v2,"bx-")
plt.xticks(x)
plt.grid(True)
plt.show()
print("Maksimum hız: {:.3f} m/s".format(max(v1)))
print(" Son hız: {:.3f} m/s".format(v1[-1]))
Maksimum hız: 8.854 m/s Son hız: 4.427 m/s
Grafik bize zaten tahmin ettiğimiz şeyi söylüyor: başlangıç ve bitiş hızları aynı olsa da, kırmızı yoldan ilerleyen top maksimum hıza daha 2. metrede ulaşıyor ve bu hızını 15. metreye kadar koruyor. Mavi yoldan ilerleyen top ise yolun çoğunu maksimum hızın yarısı kadarında seyrettikten sonra, 11. ve 12. saniyeler arasında, 1 saniyeliğine maksimum hıza çıkabiliyor ama sonra yine yarı-hıza dönüyor.
Konum-zaman grafiğini çıkarmak için Fizik I dersinde gördüğünüz sabit ivme (ivmenin sabit olduğunu nereden biliyoruz? ;) altındaki doğrusal hareket denklemlerini hatırlayalım - bildiğiniz üzere 5 parametreyi ($(x-x_0), v_0, v, a, t$) eleye eleye, hareket denklemini 5 farklı biçimde yazabiliyorduk: $$\begin{gather*} v = v_0+a t\;\;(1)\quad[x-x_0]\\ x-x_0 = v_0t+\frac{1}{2}a t^2\;\;(2)\quad[v]\\ v^2 = v_0^2+2a\left(x-x_0\right)\;\;(3)\quad[t]\\ x-x_0 = \frac{1}{2}\left(v_0+v\right)t\;\;(4)\quad[a]\\ x-x_0 = vt-\frac{1}{2}a t^2\;\;(5)\quad[v_0] \end{gather*}$$
(hangi denklemde hangi parametrenin elenmiş olduğu köşeli parantez içinde belirtilmiştir)
Bizim elimizde konumlar ve hızlar olduğundan ve zamanı aradığımızdan işimize en uygun geleni (4) numaralı denklem. O denklemde $t$'yi yalnız bırakırsak: $$t=\frac{2(x-x_0)}{v+v_0}$$
olur ki, bu tam da aradığımız cinsten bir ilişki:
$$t_i=\frac{2(x_i-x_{i-1})}{v_i+v_{i-1}}$$bu iteratif ilişkiyi koda dökersek:
t1 = [0]
t2 = [0]
for i in range(1,N):
t1.append(t1[-1]+2*(x[i]-x[i-1])/(v1[i]+v1[i-1]))
t2.append(t2[-1]+2*(x[i]-x[i-1])/(v2[i]+v2[i-1]))
# Bonus: Buraya neden "t1[-1]+"" & "t2[-1]+" eklemesi yaptik?
plt.plot(t1,x,"r.-")
plt.plot(t2,x,"b.-")
plt.grid(which="minor",alpha=0.5)
plt.grid(which="major")
plt.minorticks_on()
plt.show()
Sonuç olarak görünüyor ki, kırmızı yolda giden top parkuru:
t1[-1]
2.296415919884179
saniyede, mavi yoldan giden top ise:
t2[-1]
3.87755474996837
saniyede tamamlıyor.
Simülasyonunu yaptığımız bu güzelliği deneysel olarak görmek isterseniz, Bruce Yeany bunu gayet güzel bir videoda göstermekte:
Big High Low track // Homemade Science with Bruce Yeany
Ayrıca bu yaz kendinize bir programlama projesi arıyorsanız, size tavsiyem son derece ilginç olan Galileo yolunu bu soruda yaptığımız gibi çözümlemenizdir. Galileo yolu, farklı konumlardan aynı anda bırakılan iki topu aynı anda aşağı ulaştıran yollardır (detay ve demonstrasyon için bkz. Physics marble track review part one // Homemade Science with Bruce Yeany (1:42'den itibaren) veya Identical track race science /// Homemade Science with Bruce Yeany). Tarihçesi ve teorik arkaplanı için: The Brachistochrone, with Steven Strogatz; yapılışı için de The mysterious isochronous curve videolarını tavsiye ederim.