Project: katya belga - ud_2019

Path: assignments/assignment16/snell's law and Fermat's Principle.ipynb

Views: ²⁴¹

Kernel: Python 3 (Anaconda 2019)

name2-ו name1 הקלידו את שימכם ואת שם בן/בת זוגכם

In [26]:

name1="Katya"
name2=" IDO:)  "

חוק סנל ועיקרון פרמה-הזמן המינימאלי

נחשב את המסלול המהיר ביותר

מצילה הנמצאת בנקודה (x1,y1) רואה טובע הנמצא בנקודה (x2,y2). מהירות הריצה של המצילה ביבשה היא v1 ואילו במים היא שוחה במהירות v2.

התרשים מתאר את הבעיה:

In [0]:

הנקודה השמאלית התחתונה מייצגת את המקום בו נמצאת המצילה. הנקודה הימנית העליונה מייצגת את המקום בו נמצא הטובע. הקו האופקי המקווקו הוא קו x=0. הקו המאונך המלא, המחלק את התמונה לשתיים, הוא קו המפריד בין היבשה למים. נקודת המפגש בין הקו המקווקו והקו המלא הוא ראשית הצירים.

תרגיל 1

אילו מהירויות ההתקדמות של המצילה במים וביבשה היו זהות, רשמו מה היה המסלול המהיר ביותר כדי להציל את הטובע.

אילו מהירויות ההתקדמות של המצילה במים וביבשה היו זהות, המסלול המהיר ביותר כדי להציל את הטובע היה קו ישר

תרגיל 2

הפונקציה lifeguard_C_time שבתא שלמטה צריכה להחזיר את הזמן הלוקח למצילה לנוע בין המיקום שלה לקו המים בנקודה C. שיעורי הנקודה C הוא לאורך הציר x=0. הפרמטרים שהפונקציה מקבלת הם שיעור ה-y של מקום הנקודה C, מיקום המצילה ומהירותה ביבשה. השלימו את הפונקציה כך שהיא תחזיר את הזמן בין הנקודה C ומיקום המצילה.

In [27]:

from math import sqrt
def lifeguard_C_dist(y,x1,y1,v1):
    lifeguard= (x1,y1)
    c = (0,y)
    dis = sqrt( ((lifeguard[0]-c[0])**2)+((lifeguard[1]-c[1])**2) )
    time = dis/v1
    return(time)
    
lifeguard_C_dist(5,-1,2,1.5)

2.1081851067789197

תרגיל 3

כתבו פונקציה בשם drowned_C_time. הפונקציה תקבל את אותה נקודה y כמו בתרגיל 2, מיקום הטובע ומהירות השחיה של המצילה במים. הפונקציה צריכה להחזיר את הזמן שלוקח למצילה לשחות בין הנקודה C והטובע.

In [1]:

from math import sqrt
def drowned_C_time(y,x2,y2,v2):
    drowned= (x2,y2)
    c = (0,y)
    dis = sqrt( ((drowned[0]-c[0])**2)+((drowned[1]-c[1])**2) )
    time = dis/v2
    return(time)

drowned_C_time(5,6,10,0.8)

9.762812094883317

תרגיל 4

במידה והקודים שכתבתם נכונים (בתרגילים 2 ו- 3), החיבור של שני הקודים הקודמים יחזיר את הזמן שלוקח למצילה להציל את הטובע כתלות בשיעור ה- y של הנקודה C, מהירויות המצילה במים וביבשה ומיקומם של הצילה והטובע. כתבו פונקציה אחת הקוראת לשתי הפונקציות הקודמות ומחשבת את הזמן שלוקח למצילה להגיע לטובע דרך נקודה C.

In [29]:

from math import sqrt
def lifeguard_C_dist(y,x1,y1,v1):
    lifeguard= (x1,y1)
    c = (0,y)
    dis = sqrt( ((lifeguard[0]-c[0])**2)+((lifeguard[1]-c[1])**2) )
    time = dis/v1
    return(time)

def drowned_C_time(y,x2,y2,v2):
    drowned= (x2,y2)
    c = (0,y)
    dis = sqrt( ((drowned[0]-c[0])**2)+((drowned[1]-c[1])**2) )
    time = dis/v2
    return(time)

def saving_time(x1,y1,v1,x2,y2,v2,y):
    time1 = lifeguard_C_dist(y,x1,y1,v1)
    time2 = drowned_C_time(y,x2,y2,v2)
    return (time1 + time2)

saving_time(1,-2,1,2,3,1,-0.5)

5.833904511881269

תרגיל 5

ישנם מספר שיטות לחשב מסלול עם זמן מינמאלי. אחת השיטות היא השיטה שלמדנו בשבוע שעבר (בה בדקנו כל פעם את אורך המסלול, חצינו את המסלול לקו האמצע, חישבנו שוב את אורך המסלול החדש והחלפנו בינו לבין המסלול הארוך ביותר מבין שני הקודמים).

שיטה נוספת למציאת ערך ה y שבו המסלול הוא מהיר ביותר הוא להתחיל בחישוב אורך המסלול כאשר y=y0 ולהשוות אותו למסלול בו y=y0+dy כאשר הערך dy יקבע את גודל השגיאה בחישוב כי הוא מתאר את אורך הצעד בין y ראשון ל- y הבאה.

הזמן שלוקח למצילה להגיע לטובע, עבור מיקומים קבועים של המצילה והטובע , תלוי במהירויות היחסיות של המצילה בים וביבשה.

כתבו פונקציה המחשבת את הזמן הקצר ביותר שיקח למצילה להגיע לטובע. אתם מקבלים כפרמטרים את מיקומי המצילה והטובע, את המהירויות של המצילה בים ביבשה ואת ערך השגיאה של הבדיקה שלכם.

In [30]:

from math import sqrt

def C_time(x1,y1,v1,x2,y2,v2,dy):
    yc1,yc2 = y1,y2
    drowned= (x2,y2)
    c = (0,yc2)
    lifeguard= (x1,y1)
    lc = []
    ltimes = []

    
    min_y = min(yc2,yc1)
    yc2 = yc2 + dy
    for c in range(1000000):
        
        
        yc2= yc2-dy
        #print(yc2)
        if yc2< min_y:
            break
        lc.append(yc2)
        def dy_way(dy):
            
            
            drowned= (x2,y2)
            cpoint = (0,yc2)
            lifeguard= (x1,y1)
            diss = sqrt( ((drowned[0]-cpoint[0])**2)+((drowned[1]-cpoint[1])**2) )
            timedrown = diss/v2
            diss1 = sqrt( ((lifeguard[0]-cpoint[0])**2)+((lifeguard[1]-cpoint[1])**2) )
            timelifeg = diss1/v1
            time = (timedrown+timelifeg)
            ltimes.append(time)
            #print(cpoint,time)
            return(time)
        
        dyy = dy_way(dy)




    h = ltimes.index(min(ltimes))
    
    return("when c is (0," +str(lc[h])+ ") the time is the shortest - " , min(ltimes))
   
C_time(-1,-2,8,1,2,8,0.007)

('when c is (0,-0.0019999999999859453) the time is the shortest - ',
 0.5590170390963338)

תרגיל 6

העריכו את השגיאה בחישוב שיעור ה-y של הנקודה C עבור ערכי dy שונים הנעים בין 0.05-0.5

In [12]:

import my_statistics
import math
from math import sqrt
def lifeguard_C_dist(y,x1,y1,v1):
    lifeguard = (x1, y1)
    c = (0, y)
    s = sqrt(((lifeguard[0] - c[0])**2)+((lifeguard[1] - c[1])**2))
    time = s / v1
    return(time)

def drowned_C_time(y,x2,y2,v2):
    drowned = (x2, y2)
    c = (0, y)
    s = sqrt(((drowned[0] - c[0])**2)+((drowned[1] - c[1])**2))
    time = s / v2
    return(time)

def saving_time (x1, y1, x2, y2, v1, v2, y):
    time1 = lifeguard_C_dist(y,x1,y1,v1)
    time2 = drowned_C_time(y,x2,y2,v2)
    return(time1 + time2)

def the_shortest_time (x1, y1, x2, y2, v1, v2, dy):
    ls = []
    y = y1
    time = saving_time (x1, y1, x2, y2, v1, v2, y)
    
    run = True
    while run == True:
        
        before_c = y
        y = y + dy
        test_time = saving_time (x1, y1, x2, y2, v1, v2, y)
        
        if test_time < time:
            time = test_time
        
        else:
            run = False
    
    ls.append(before_c)
    ls.append(y)
    
    return (ls)

def make_dy_list():
    ls = []
    i = 0.5
    while i >= 0.05:
        ls.append(i)
        i = i - 0.05
    return (ls)

dy_list = make_dy_list()

def calculation_error (x1, y1, x2, y2, v1, v2, dy_list):
    std_dictionary = {}
    for i in dy_list:
        ls = the_shortest_time (x1, y1, x2, y2, v1, v2, i)
        std = my_statistics.std(ls)
        std_dictionary['dy is', i] = std
    
    return (std_dictionary)

calculation_error (-20, -15, 18, 5, 1.5, 0.8, dy_list)

{('dy is', 0.5): 0.25,
 ('dy is', 0.45): 0.22499999999999998,
 ('dy is', 0.4): 0.2,
 ('dy is', 0.35000000000000003): 0.17500000000000004,
 ('dy is', 0.30000000000000004): 0.15000000000000002,
 ('dy is', 0.25000000000000006): 0.12500000000000003,
 ('dy is', 0.20000000000000007): 0.10000000000000003,
 ('dy is', 0.15000000000000008): 0.07500000000000007,
 ('dy is', 0.10000000000000007): 0.050000000000000044,
 ('dy is', 0.05000000000000007): 0.025000000000000022}

השגיאה בחישוב ערך הוואי בנקודה סי תלוי בדלתא וואי, כלומר גודל הקפיצות בין בדיקה לבדיקה, משום שזה קובע את מידת הדיוק שניתן להגיע לתוצאה הנכונה. ככל שהקפיצה גדולה יותר, השגיאה תהיה גדולה יותר שכן יש רווחים גדולים יותר בין בדיקה לבדיקה. .

עקרון פרמה כמקדים לחוק סנל

הדוגמה של המצילה והטובע מדגים את עיקרון פרמה המסביר את מסלול האור כאשר הוא עובר מתווך אחד לתווך אחר. הסרטון שבהמשך (באנגלית- מצטערת) יסביר יותר מפורט את העקרון ויחבר אותו לחוק סנל.

In [1]:

from IPython.display import YouTubeVideo
YouTubeVideo("4l2thi5_84o")

תרגיל 7

כתבו פונקציה המחזירה את זוית השבירה של האור בתווך חדש, בהינתן את זווית הפגיעה ואת שני מקדמי השבירה של התווך הראשון והשני.

שימו לב שפייטון מחשב זויות רק ברדיאנים

בהנחה שהאור בא מהתווך בעל מהשבירה הגבוה, התרעו במשפט מה תהיה הזוית הקריטית

In [7]:

import math
def snell1(n1,n2,theta1):
    critic = math.degrees(math.asin(n2/n1))
    if theta1>critic:
            return("the critic theta is "+ str(critic)+"and because the theta1 is bigger than that all the light will be returned so there is no theta2")
    else :
        theta1_radian = math.radians(theta1)
        sin_radian_theta1= math.sin(theta1_radian)


        radian_sin_theta2 = ((n1 * sin_radian_theta1)/n2)

        theta2_radian = math.asin(radian_sin_theta2) #
        theta2 = math.degrees(theta2_radian)


        return(theta2)

snell1(1.333,1.0003,23)

31.378438522021522

תרגיל 8

חזרו על הפעלה אבל עכשיו כתבו פונקציה המחזירה את מקדם השבירה של התווך החדש, בהינתן את זווית הפגיעה, זוית השבירה ומקדמי השבירה של התווך הראשון .

In [3]:

import math
def snell2(n1,theta1,theta2):
    
    theta1_radian = math.radians(theta1)
    theta2_radian = math.radians(theta2)
    
    sin_theta1 = math.sin(theta1_radian)
    sin_theta2 = math.sin(theta2_radian)
    
    n2 = ((n1 * sin_theta1)/ sin_theta2)
    return (n2)
snell2(1.333,45,70.3407)

1.0009170307174313

תרגיל 9

שרטטו מקרה אחד של מסלול אור מכל אחד משני הפונקציות הקודמות .

In [8]:

import math
import matplotlib.pyplot as plt
from math import pi


n1= float(input("enter refractive index :"))
n2=float(input("enter second refractive index :"))
theta1=float(input("angle in degrees ;"))



critic = math.degrees(math.asin(n2/n1))
if theta1>critic:
    theta2 = ("the critic theta is "+ str(critic)+" and because the theta1 is bigger so there is no theta2")
    print(theta2)
else :
    theta1_radian = math.radians(theta1)
    sin_radian_theta1= math.sin(theta1_radian)


    radian_sin_theta2 = ((n1 * sin_radian_theta1)/n2)
    theta2_radian = math.asin(radian_sin_theta2) #
        


    theta2_deg = ("theta2 ="+ str(math.degrees(theta2_radian)) )

    l = 2.09
    ll = 8
    if theta2_deg != type(l) or theta2_deg != type(ll):
        exit


    print( theta2_deg)

    
    
    
    
    
    
    
plt.polar([theta1_radian,0,1.5*pi-theta2_radian],[5,0,5], lw = 4, c = 'b')
plt.polar([0.5*pi, 0.5 *pi],[5,4], lw = 3.5, c = 'm')
plt.polar([0.5*pi, 0.5 *pi],[3,2], lw = 3.5, c = 'm')
plt.polar([0.5*pi, 0.5 *pi],[1,0], lw = 3.5, c = 'm')

plt.polar([1.5*pi, 1.5 *pi],[1,2], lw = 3.5, c = 'm')
plt.polar([1.5*pi, 1.5 *pi],[3,4], lw = 3.5, c = 'm')

plt.polar([pi, 0, 0], [5,0,5], lw = 5, c = 'm')

enter refractive index :

enter second refractive index :

angle in degrees ;

theta2 =31.284419182523177

[<matplotlib.lines.Line2D at 0x7f48957b7e90>]

In [13]:

import math
from math import pi
import matplotlib.pyplot as plt



n1= float(input("enter refractive index :"))
theta1=float(input("angle in degrees ;"))
theta2=float(input("angle in degrees ;"))
    
theta1_radian = math.radians(theta1)
theta2_radian = math.radians(theta2)

sin_theta1 = math.sin(theta1_radian)
sin_theta2 = math.sin(theta2_radian)
    
n2 = ((n1 * sin_theta1)/ sin_theta2)
    


plt.polar([theta1_radian,0,1.5*pi-theta2_radian],[5,0,5], lw = 4, c = 'b')
plt.polar([0.5*pi, 0.5 *pi],[5,4], lw = 3.5, c = 'g')
plt.polar([0.5*pi, 0.5 *pi],[3,2], lw = 3.5, c = 'g')
plt.polar([0.5*pi, 0.5 *pi],[1,0], lw = 3.5, c = 'g')

plt.polar([1.5*pi, 1.5 *pi],[1,2], lw = 3.5, c = 'g')
plt.polar([1.5*pi, 1.5 *pi],[3,4], lw = 3.5, c = 'g')

plt.polar([pi, 0, 0], [5,0,5], lw = 5, c = 'g')

print("theta1 = ",theta1 , "theta2 =", theta2)

n2 = ("n2 ="+str(n2) )
print(n2)
plt.text(-2,10,n2, fontsize = 20)

enter refractive index :

angle in degrees ;

angle in degrees ;

theta1 =  45.0 theta2 = 70.0
n2 =1.0030655966345146

Text(-2, 10, 'n2 =1.0030655966345146')

In [0]: