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:

$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$ $F=m.a$ wil dit zeggen dat $a={\frac {F}{m}}$ $a={\frac {F}{m}}$
- Dus voor $F_{d}$ $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.
Wanneer we dit toepassen voor hoeken van 89, 75, 45 en 30 graden resulteert dit in volgende grafiek:

- Ik ben nog niet zeker of alles wel juist is... Misschien moet ik daar eens goed over slapen.
- Ook, zoals bij bv een kogel, zou de afstand die een pijl aflegt bij +/- 30° verder moeten zijn dan bij 45°.. dus er is niet iets niet juist....
Vlucht van de pijl met en zonder luchtweerstand, uitgezet in de tijd.
- Ik ben niet zeker of dit 100% klopt want de blauwe lijnen (89°) liggen erg dicht bijeen, dichter dan dat ik gevoelsmatig zou inschatten. Na te kijken aub.

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

def simulate_trajectory(x0, y0, v0, theta, dt, num_timesteps, diameter, C_factor, air_density,  arrow_mass, AR, DEBUG):
    """
    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
    diameter: diameter van de pijl
    C_factor: drag coefficiënt (Cd). 
    air_density: dichtheid van de lucht. (genomen bij 0°C)
    AR: air resistance: True/False: of Air resistance in rekening moet worden gebracht of niet.
    DEBUG: debug mode: True/False: indien True worden een aantal waarden geprint naar de console.


    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
    
    # 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)
    # als er geen luchtweerstand is hebben we eigenlijk geen terminal velocity nodig. 
    
    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) * vx / 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.
        # vx = vx - (air_resistance_decelleration) * dt
        # vy = vy - (g + air_resistance_decelleration ) * dt
        #
        # Dit was een fout... ik moet de x- en y-component van de luchtweerstand gebruiken... die stond er eerst niet bij....shame on me ;-)... dank je douche :-)
        if i==0:
            aanvalshoek=theta
        else:
            aanvalshoek=np.arctan(vys[-1]/vxs[-1])
        vx = vx - (air_resistance_decelleration*np.cos(aanvalshoek)) * dt
        vy = vy - (g + air_resistance_decelleration*np.sin(aanvalshoek) ) * dt

#         print(vx, vy)
#         print(v0, vx,vy)
        # wanneer de neerwaardse snelheid groter wordt dan de terminal velocity, maak het gelijk aan de terminal velocity.
# Dit geeft rare plots, dus maar achterwege gelaten.... na te kijken...
#        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)
# 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) <= 0:  # stop simulation when vy becomes smaller than or equal to zero.. let arrow stop at ground
            break
    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.

# Set initial conditions
g=9.81 #N/kg


# rho=1.3 #kg/m^3 Air density
launch_x = 0
launch_y = 0
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)

# 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'
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°'
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=350
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']


# 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],AR=True,DEBUG=False)
#     steps=1000
#     how_far=max_distance(hoek, ss[index],launch_y,stop_y)
#     my_range=np.arange(launch_x, how_far, (how_far-launch_x)/steps)
    # Plot trajectory
    plt.plot(my_x, my_y,color=my_colors[index])
    my_x, my_y= simulate_trajectory(launch_x, launch_y, ss[index], hoek, dt, num_timesteps, dd[index] , CC[index], rr[index], mm[index],AR=False,DEBUG=False)
    # Alternatieve functie om het traject zonder luchtweerstand te berekenen geeft hetzelfde resultaat..
    #     plt.plot(my_range,y_positie(hoek, 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()

De vlucht van een pijl zonder en met luchtweerstand

Contents

De vlucht van een pijl zonder luchtweerstand

Vlucht van de pijl rekening houdend met de luchtweerstand.

Python code

imports

helper functies

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

Eigenlijk programma om de plot aan te maken.

Navigation menu

Page actions

Page actions

Personal tools

Navigation

Search

Tools