De vlucht van een pijl zonder en met luchtweerstand

De vlucht van een pijl zonder luchtweerstand

• Het traject van een pijl is, bij afwezigheid van luchtweerstand, enkel afhankelijk van de snelheid bij vertrek, de hoek waarin de pijl afgeschoten wordt, de hoogte van waarop de pijl vertrekt, de valversnelling en de hoogte van het eindpunt.
• Om de formule te bepalen hebben we dus nodig:
  • snelheid $v_{0}\left(in{\frac {m}{s}}\right)$
  • valversnelling $g=9.81\left(in{\frac {m}{s^{2}}}\right)$
  • $\theta _{0}$ de hoek waaronder de pijl afgeschoten wordt (in graden)
  • begin hoogte (in m)
  • eind hoogte (in m)
  • $x_{0}$: horizontale beginpositie
  • $x$ = de afgelegde horizontale afstand
  • $y_{0}$: verticale beginpositie
  • $y$ = de afgelegde verticale afstand (=hoogte)
• De positie van de pijl wordt bepaald door de formule (uit "Doing Physics with Scientific Notebook: A Problem Solving Approach, Joseph Gallant, 2012"):

$y=y_{0}+tan(\theta _{0})\left(x-x_{0}\right)-{\frac {g}{2v_{0}^{2}cos^{2}\theta _{0}}}(x-x_{0})^{2}$

• de maximale afstand, R, die een pijl kan afleggen (zonder luchtweerstand) wordt gegeven door de formule

$R={\frac {v_{0}^{2}}{2g}}\left(1+{\sqrt {1-{\frac {2g}{v_{0}^{2}sin^{2}\theta _{0}}}(x-x_{0})}}\right)sin2\theta _{0}$

• Wanneer de begin en eind hoogte dezelfde is, kan formula vereenvoud worden tot:

$R={\frac {v_{0}^{2}}{g}}sin2\theta _{0}$

• • Deze afstand is maximaal voor een hoek van 45°. Dan wordt $sin2\theta _{0}$ gelijk aan 1 en is de formule

$R_{max}={\frac {v_{0}^{2}}{g}}$

• De tijd ($T$) dat de pijl onderweg is wordt gegeven door de formule

$T={\frac {v_{0}}{g}}\left(1+{\sqrt {1-{\frac {2g}{v_{0}^{2}sin^{2}\theta _{0}}}(y-y0)}}\right)sin\theta _{0}$

• De maximale hoogte ($H$) dat een pijl kan bereiken wordt gegeven door de formule:

$H=y_{0}+{\frac {v_{0}^{2}}{2g}}sin^{2}\theta _{0}$

• Hieronder staan de trajecten voor een pijl afgeschoten aan 200 fps (links) en 270 fps (rechts).
  • De vorm van de trajecten is dezelfde voor de 200 fps en de 270 fps pijl, enkel de hoogte en afstand is verschillend.

• 

  Vlucht van een pijl aan 200 fps

• 

  Vlucht van een pijl aan 270 fps

• Indien er geen luchtweerstand is, zou je zelfs met een moderne compound boog van 70# gemakkelijk over de Eifeltoren heen kunnen schieten!
  • Vandaar altijd zorgen voor een goede pijlenopvang achter het doel, nooit de boog naar boven aanspannen, enz.

• Vermits een model zonder luchtweerstand niet realistisch is, dienen we de berekeningen te herhalen met luchtweerstand. (zie verder)

Vlucht van de pijl rekening houdend met de luchtweerstand.

• De luchtweerstand voor een object in beweging wordt weergegeven door de volgende formule
  • $F_{d}={\frac {1}{2}}\rho v^{2}C_{d}A$
• met:
  • $\rho$ de dichtheid van het medium waarin het voorwerp zich voortbeweegt, hier de lucht.
  • $v$ de snelheid van het voorwerp in m/s
  • $C_{d}$ de drag coefficiënt (weerstandscefficiënt)
  • $A$ de oppervlakte van de doorsnede loodrecht op de bewegingsrichting
  • $F_{d}$ de kracht die uitgeoefend wordt op het voorwerp tijdens de beweging in het medium (lucht)

• Hierboven hielden we enkel rekening met de valversnelling in de y-component, moeten we hier rekening houden met de luchtweerstand voor zowel de x- als de y-component van de snelheid.
  • $v_{0}$ beginsnelheid
  • $\theta$ de hoek waaronder de pijl wordt afgeschoten.
  • $vx_{0}=v_{0}cos(\theta )$ de x-component van de beginsnelheid
  • $vy_{0}=v_{0}sin(\theta )$ de x-component van de beginsnelheid

• We kunnen dus op zowel de x- als de y-component van de snelheid, per klein tijdseenheid dat het voorwerp bewogen heeft, de nodige aanpassingen doen. Dit is de methode van Euler en is een numerieke methode om dit probleem op te lossen.
  • Per klein tijdsinterval $dt$ kunnen we de aangepaste snelheid berekenen.
• Vermits $F=m.a$ wil dit zeggen dat $a={\frac {F}{m}}$
  • Dus voor $F_{d}$ kunnen we dus stellen dat de (negatieve) versnelling door de luchtweerstand gelijk is aan:
    • $a_{d}={\frac {F_{d}}{m}}={\frac {1}{2}}{\frac {\rho v^{2}C_{d}A}{m}}$
  • Deze versnelling (=vertraging want werkt in tegengestelde richting aan de snelheid van het voorwerp) kunnen we dan gebruiken om de snelheid
    • voor de x-component van de snelheid
      • $\Delta vx=-a_{d}dt$
      • $\Leftrightarrow v_{2}-v_{1}=-a_{d}dt$
      • $\Leftrightarrow v_{2}=v_{1}-a_{d}dt$
    • voor de y-component van de snelheid
      • hier werkt ook de valversnelling mee
      • $\Delta vy=-(g+a_{d})dt$
      • $\Leftrightarrow v_{2}-v_{1}=-(g+a_{d})dt$
      • $\Leftrightarrow v_{2}=v_{1}-(g+a_{d})dt$
    • Dus de nieuwe snelheid op $dt$ verder in de tijd wordt dus berekend op basis van de voorgaande snelheid + de kleine aanpassing. Door dit te doen vanaf de beginsnelheid en dit te herhalen over het gehele traject bekomen we dus de baan van de pijl met luchtweerstand.
  • Een voorwerp dat naar beneden valt zal versnellen totdat het aan zijn eindsnelheid (terminal velocity) komt.. vanaf dat moment is de snelheid van het vallend voorwerp constant en versnelt het niet meer.
  • De Eindsnelheid/Terminal velocity wordt weergegeven door de formule: $v_{term}={\sqrt {\frac {2m.g}{\rho AC_{d}}}}$
  • In het computer programma dat we gebruiken om de baan van de pijl met luchtweerstand te berekenen, moeten we ook rekening houden dat indien de snelheid bij het terug naar beneden vallen groter zou worden dat de Eindsnelheid, om deze dus te beperken tot maximaal de Eindsnelheid/terminal velocity.
  • ${\displaystyle }$
• Wanneer we dit toepassen voor hoeken van 89, 75, 45 en 30 graden resulteert dit in volgende grafiek:

• Vlucht van de pijl met en zonder luchtweerstand, uitgezet in de tijd.

• Hoe zit het nu met hoger schieten dan de Eifeltoren... lukt dat dan nog met een boog en hoe snel moet je pijl dan wel niet zijn?
  • Spoiler: een 700 grain pijl aan 305 fps afgeschoten onder een hoek van 86° zou er nog net (332m) over vliegen en aan de andere kant van de voet van de Eifeltoren landen. Warning: do not try this at home.. or in Paris!

Nota over de $Cd$ drag coefficiënt

• • De $Cd$-waarde van een pijl is sterk afhankelijk van hoe de pijl is opgebouwd. Een flu-flu pijl zal uiteraard veel sneller remmen en dus een veel grotere $Cd$-waarde hebben dan een dan een gewone pijl en kleine veren die perfect parallel aan de schacht gekleefd zijn.
  • Een hoge spine-waarde, en dus een slappe spine, zal de pijl doen "paradoxen" over z'n traject dus ook de $Cd$-waarde laten toenemen.
  • In een artikel werd de $Cd$-waarde van de pijl berekend door de pijl magnetisch op te hangen in een windtunnel. Dit levert een zeer accurate meting op van de $Cd$-waarde van de pijl. In het artikel vonden ze $Cd$-waarden van 2.6 voor een pijl met spin-wings en een $Cd$-waarde van 1.5 voor een pijl met GasPro vanes.
  • Een naakte schacht heeft een $Cd$-waarde van $Cd=0.9$ zoals getoond in deze video dicht bij de waarde van 0.94 uit dit artikel.
  • De $Cd$-waarde die we hier gebruiken van $Cd==1.42$ is afkomstig van een video van een persoon die een aantal verschillende pijlen onder een hoek van 45° afschiet.
  • Ter vergelijking, een vrachtauto heel een $Cd$-waarde van 0.6, dus minder dan de helft van sommige pijlen.

Python code

• Syntaxhighlighting lijkt niet te werken, sorry.

<syntaxhighlight lang="python" line> def quick_sort(arr): less = [] pivot_list = [] more = [] if len(arr) <= 1: return arr else: pass ‎</syntaxhighlight>

imports

import pandas as pd
import numpy as np

import matplotlib.pyplot as plt

helper functies

# Define helper functions
# KE
def kinetic_energy(m, v):
    return 0.5*(m*0.0647989/1000)*(v*0.3048)*(v*0.3048)
# momentum
def momentum(m, v):
    return (m*0.0647989/1000)*(v*0.3048)

def grain2gram(x):
    return x * 0.0647989

def grain2kg(x):
    return grain2gram(x)/1000

def gram2grain(x):
    return x / 0.0647989

def kg2grain(x):
    return x*15432.3584

def fps2ms(x):
    return x * 0.3048

def ms2fps(x):
    return x / 0.3048

def inch2meter(x):
    return(x*0.0254)
def meter2inch(x):
    return(x/0.0254)

def lbs2Newton(x):
    return(x*4.4482216)
def Newton2lbs(x):
    return(x/4.4482216)

Functies die het traject van de pijl met en zonder luchtweerstand berekenen

###########
#  MASTER #
###########

import numpy as np
import matplotlib.pyplot as plt

def simulate_trajectory(x0, y0, v0, theta, dt, num_timesteps, diameter, C_factor, air_density,  arrow_mass, AR, DEBUG, TIMEPLOT, stop_height):
    """
    Simulates the trajectory of an arrow under the influence of air resistance.
    
    Parameters:
    x0 (float): initial x-coordinate of the arrow
    y0 (float): initial y-coordinate of the arrow
    v0 (float): initial velocity of the arrow
    theta (float): initial launch angle of the arrow (in radians)
    dt (float): time step size
    num_timesteps (int): number of timesteps to simulate
    
    Returns:
    xs (list of floats): x-coordinates of the arrow at each timestep
    ys (list of floats): y-coordinates of the arrow at each timestep
    """
    xs = [x0]
    ys = [y0]
    vs = [v0]
    vx = v0 * np.cos(theta)
    vy = v0 * np.sin(theta)
    vxs = [vx] # list of horizontal speeds
    vys = [vy] # List of vertical speeds
    v_term=0
    if TIMEPLOT==True:
        timevalues=[0]
    
    # bereken de sectional diameter van de pijl
    A=np.pi*(diameter/2)**2
    # de valversnelling houden we constant.
    g=9.81
    # include terminal velocity
    if AR==True:
        v_term=np.sqrt(2*arrow_mass*g/(air_density*A*C_factor))
        if DEBUG==True:
            print("The terminal velocity is: ",v_term)
        
    for i in range(num_timesteps):
        # Compute air resistance
        # We berekenen de versnelling (=vertraging) door luchtweerstand.
        if AR==True:
            air_resistance_decelleration=0.5*air_density*A*C_factor*np.sqrt(vx**2 + vy**2) **2 / arrow_mass
        else:
            air_resistance_decelleration=0
        # F=m.a Dus a = F/m.. dus delen door arrow_mass om versnelling (negatief gebruiken) te krijgen
        # v² wordt berekend door sqrt van kwadraten van vx en vy, vermenigvuldig met vx omdat vx altijd positief is (of toch zou moeten zijn ;-)
        # print(air_resistance)
        # Update velocity voor zowel de x- als y-richting. X-richting enkel luchtweerstand, y-richting zowel zwaartekracht als luchtweerstand.
        
        # Dit was een fout... ik moet de x- en y-component van de luchtweerstand gebruiken... die stond er eerst niet bij....
        if i==0:
            aanvalshoek=theta
        else:
            aanvalshoek=np.arctan(vys[-1]/vxs[-1])
        vx = vx - (np.abs(air_resistance_decelleration*np.cos(aanvalshoek))) * dt
        vy = vy - (g + np.abs(air_resistance_decelleration*np.sin(aanvalshoek)) ) * dt
#         print("{:.2f}".format(aanvalshoek*180/np.pi))
#         print(vx, vy)
#         print(v0, vx,vy)
        # wanneer de neerwaardse snelheid groter wordt dan de terminal velocity, maak het gelijk aan de terminal velocity.
        if (vy < -1*v_term and AR==True):
            vy= -1*v_term
            if DEBUG==True:
#                 print("terminal velocity reached ",v_term)
                print('y', end='') # add the end='' option in order not to go to a new line.
# Ik denk niet dat we terminal velocity zullen bereiken in de x-richting....niet tegengekomen tijdens het testen..
#         if ( (vx < v_term) and vy<=0 ):
#             vx= v_term
#             print('x', end='')
        # Update position
        xs.append(xs[-1] + vx * dt)
        ys.append(ys[-1] + vy * dt)
        # append also the speeds to the lists.. for debugging reasons...doen we nu niet
        vs.append(np.sqrt(vx**2+vy**2))
        vxs.append(vx)
        vys.append(vy)
        if TIMEPLOT==True:
            timevalues.append(timevalues[-1]+dt)
# We negeren Stokes nog even.. enkel bij trage snelheden...misschien later toevoegen
#         if (np.sqrt(vx**2+vy**2)*diameter)<0.015:
#             print("Stokes drag should be used!")
        if ((ys[-1] + vy*dt) <= stop_height and vy<0):  # stop simulation when vy becomes smaller than or equal to zero.. let arrow stop at ground
            break
    if DEBUG==True and TIMEPLOT==False:
        return xs, ys, vs, vxs, vys  
    if DEBUG==True and TIMEPLOT==True:
        return xs, ys, vs, vxs, vys, timevalues
    if DEBUG==False and TIMEPLOT==True:
        return xs, ys, timevalues
    else:
        return xs, ys
#     return xs, ys, vs, vxs, vys
# Als we ook de snelheiden meegeven in de return, extra parameters voorzien bij het gebruiken van deze functie.





# De functies hieronder krijgen de hoek in radialen
def y_positie(hoek,snelheid,start_hoogte, eind_hoogte, start_x, eind_x):
    g=9.81
    theta=hoek
    return ( start_hoogte + np.tan(theta)*(eind_x-start_x) - g*(eind_x-start_x)**2/(2*(snelheid*np.cos(theta))**2  )  )

def max_distance(hoek,snelheid,start_hoogte,eind_hoogte):
    g=9.81
    theta=hoek
    return ( snelheid**2*np.sin(2*theta)/(2*g) * ( 1 + np.sqrt(1 - 2*g*(eind_hoogte-start_hoogte)/( (snelheid*np.sin(theta))**2)  )  )  )

Eigenlijk programma om de plot aan te maken.

#######################################################

# Parameters over de lanceerhoek, gewicht van de pijl, drag coefficiënt, diameter, luchtweerstand en snelheid van de pijl.
# Door deze parameters in een lijst te zetten kunnen we gemakkelijk verschillende grafieken maken door deze parameters aan te passen.

hoeken=[89,75,45,30] # hoek in graden
hh=list(np.array(hoeken)*np.pi/180)
mm=[grain2kg(550)]*len(hoeken) # gewichten in grains
CC=[1.42]*len(hoeken) # drag coefficiënt
dd=[inch2meter(0.280)]*len(hoeken) # diameter
rr=[1.3]*len(hoeken) #kg/m^3 Air density
ss=[fps2ms(270)]*len(hoeken)

# Verschillende waarden voor Cd getest (drag coefficient)
# C=0.295 # Bullet https://en.wikipedia.org/wiki/Drag_coefficient
# C=1.65 # https://www.sciencedirect.com/science/article/pii/S1877705813010680#:~:text=The%20arrow%20launched%20by%20the,induces%20the%20boundary%20layer%20transition.
# C=0.9 # based on video, no fletching, https://www.youtube.com/watch?v=1L8r4hAgVsw
# C=1.42 # experimental by someone in a field
# The shape of the projectile influences its coefficient of drag, which determines how strongly air resistance affects an object's flight path. The higher the coefficient, the larger the effect. 
# For shapes, you can choose "none," which has zero drag; "wing shape," such as the wing of an airplane with a very low coefficient of 0.2; a "sphere," which has a coefficient of 0.5; 
# and a "flat plate," which is anything with a face of a large, flat surface area, with a coefficient of 1.28.
# Uiteindelijk een waarde van 1.42 genomen.. dit moet experimenteel bevestigd worden. De Cd uit het artikel is voor een heel slappe pijl die veel paradox heeft, een stijve pijl uit een compound boog zal een lagere Cd hebben. 
# Spinwing vs Gaspro veren gaf ook een heel groot verschil.
# Een andere persoon berekend Cd aan de hand van de ratio met G1... Dit zou voor zo'n pijl Cd=4.1 opleveren, wat me veel lijkt: 
# https://sites.google.com/site/technicalarchery/technical-discussions-1/drag-coefficients-of-bullets-arrows-and-spears

# Set initial conditions
g=9.81 #N/kg


# rho=1.3 #kg/m^3 Air density
launch_x = 0
launch_y = 2.20
stop_y=0

dt = 0.01  # time step size of 0.1 s
num_timesteps = 10000  # simulate for 1000 timesteps

# print("Check for Newtonian vs Strokes drag (must be more than about 0.015): ",v0*dd[0])

# volgorde parameters: (x0, y0, v0, theta, dt, num_timesteps, diameter, C_factor, air_density,  arrow_mass)

hoeken_str=''
for i in np.arange(0,len(hoeken)-2):
    hoeken_str=hoeken_str+ str(hoeken[i]) + '°, '
hoeken_str=hoeken_str+ str(hoeken[len(hoeken)-2])+'° '
if LANG=="EN":
    hoeken_str=hoeken_str+ 'and ' + str(hoeken[len(hoeken)-1])+'°'
else:
    hoeken_str=hoeken_str+ 'en ' + str(hoeken[len(hoeken)-1])+'°'

# labels
LANG='NL'

if LANG=='EN':
    my_x_axis_label='Distance (m)'
    my_y_axis_label='Height (m)'
#     my_title='Trajectory of an arrow with (solid line) and without (dotted line) air resistance for 89°, 75° , 45° and 30° angles'
    my_title='Trajectory of a {:.0f} grain arrow for '.format(kg2grain(mm[0]))+hoeken_str+' @ {:.0f} fps with and without air resistance\nstarting at a height of {:.1f} m and arriving at a height of {:.1f} m'.format(ms2fps(ss[0]),launch_y,stop_y)
elif LANG=='NL':
    my_x_axis_label='Afstand (m)'
    my_y_axis_label='Hoogte (m)'
#     my_title='Traject van een pijl rekening houdend met (volle lijn) en zonder (stippellijn) luchtweerstnad voor 89°, 75° , 45° and 30°'
    my_title='Vlucht van een {:.0f} grain pijl voor '.format(kg2grain(mm[0]))+hoeken_str+' @ {:.0f} fps met en zonder luchtweerstand\nvertrekkend van {:.1f} m hoogte en eindigend op {:.1f} m hoogte'.format(ms2fps(ss[0]),launch_y,stop_y)
else:
    my_x_axis_label='X'
    my_y_axis_label='Y'
    my_title='Title'

   
fig, ax = plt.subplots(figsize=(20, 10))
ax.set_title(my_title,fontsize=20)
ax.set_xlabel(my_x_axis_label,fontsize=16)
ax.set_ylabel(my_y_axis_label,fontsize=16)

plt.xticks(np.arange(0, 860, 20) )

ymin=-5
ymax=375
ax.set_ylim(ymin, ymax)
ax.set_xlim(-5, 700)
# ax.axis('equal')
# default colors print(plt.rcParams['axes.prop_cycle'].by_key()['color'])
my_colors=[u'#1f77b4', u'#ff7f0e', u'#2ca02c', u'#d62728', u'#9467bd', u'#8c564b', u'#e377c2', u'#7f7f7f', u'#bcbd22', u'#17becf']
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)

# Simulate trajectory
for index,hoek in enumerate(hh):
    my_x, my_y= simulate_trajectory(launch_x, launch_y, ss[index], hoek, dt, num_timesteps, dd[index] , CC[index], rr[index], mm[index],True,False, False,stop_y)
#     steps=1000
#     how_far=max_distance(hoek*180/np.pi,ss[index],launch_y,stop_y)
#     my_range=np.arange(launch_x, how_far, (how_far-launch_x)/steps)
    # Plot trajectory
#     print(max(my_y))
    plt.plot(my_x, my_y,color=my_colors[index])
    textstr = '{:.0f}°: max={:.0f}, {:.0f}'.format(hoeken[index], my_x[my_y.index(max(my_y))] , max(my_y))
    plt.text(my_x[my_y.index(max(my_y))] , max(my_y)+5, textstr, bbox=props)
    
    my_x, my_y= simulate_trajectory(launch_x, launch_y, ss[index], hoek, dt, num_timesteps, dd[index] , CC[index], rr[index], mm[index],False,False, False,stop_y)   
    # Alternatieve functie om het traject zonder luchtweerstand te berekenen geeft hetzelfde resultaat..
    #     plt.plot(my_range,y_positie(hoek*180/np.pi, ss[index], launch_y, stop_y, launch_x, my_range),color=my_colors[index],linestyle='dotted' )
    plt.plot(my_x, my_y,color=my_colors[index],linestyle='dotted' )

plt.grid(True)
  
dpi=300
myfilename='Arrow_flight_with_Air_resistance_transparent_'+LANG+'_'+str(dpi)+'dpi.png'
plt.savefig(myfilename,dpi=300, bbox_inches='tight',transparent=True) 
plt.show()