Discussion :

[RaphMPSI]

Bonjour à tous je suis nouveau sur le forum donc je ne sais pas trop comment ça fonctionne.
Je suis en galère sur un programme python en effet je cherche à modéliser la trajectoire d'une balle de golf sans frottements, je suis donc parti dans l'idée de la modéliser sous la forme d'une successions de paraboles donc l'angle de départ serait toujours le même mais la vitesse initiale de chaque parabole serait égale à la vitesse finale de la parabole précédente. Cependant dans mon programme python ne m'affiche que la première parabole et je n'arrive pas à résoudre ce problème. J'espère avoir été clair et si une âme charitable voudrait bien m'aider je suis preneur.
Voila mon programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import numpy as np
from math import pi
import matplotlib.pyplot as plt
 
g=9.81
z=0
nbr=2000
t=np.linspace(0,200,nbr)
 
def sansfrottements(t,a,v):   #a=angle alpha en degrés  v=vitesse initiale
    a=a*pi/180
    L=[]
    c=0
    d=0
    e=0
    w=0
    v1=0
    for k in range(nbr):
        if (-1/2)*g*(t[k]/(np.cos(a)*v))**2+(np.sin(a)/np.cos(a))*t[k]>0:
            c+=1
            L.append((-1/2)*g*(t[k]/(np.cos(a)*v))**2+(np.sin(a)/np.cos(a))*t[k])
            w=L[-1]
        v1=-g*(1/((v**2)*((np.cos(a))**2)))*w+(np.sin(a)/np.cos(a))
        if (-1/2)*g*((t[k]-t[c])/(np.cos(a)*v1))**2+(np.sin(a)/np.cos(a))*(t[k]-t[c])>0:
            L.append((-1/2)*g*((t[k]-t[c])/(np.cos(a)*v1))**2+(np.sin(a)/np.cos(a))*(t[k]-t[c]))
            d+=1
    return L
    print(L)
 
 
 
def tracefct(a,v):
    Y=sansfrottements(t,a,v)
    plt.figure(1)
    plt.plot(Y)
    plt.title("tracé d'une trajectoire sans frottements")
    plt.show()

Ou avec une approche différente:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
import numpy as np
from math import pi
import matplotlib.pyplot as plt
 
g=9.81
z=0
nbr=200
t=np.linspace(0,200,nbr)
c=0
 
def sansfrottements(t,a,v):   #a=angle alpha en degrés  v=vitesse initiale
    a=a*pi/180
    L=[]
    v1=0 
    for k in range(nbr):
        if (-1/2)*g*(t[k]/(np.cos(a)*v))**2+(np.sin(a)/np.cos(a))*t[k]>=0:
            L.append((-1/2)*g*(t[k]/(np.cos(a)*v))**2+(np.sin(a)/np.cos(a))*t[k])
            c+=1
    w=L[-1]
    v1=-g*(1/((v**2)*((np.cos(a))**2)))*w+(np.sin(a)/np.cos(a))        
    for k in range(len(L),nbr):
        if (-1/2)*g*((t[k]-t[c])/(np.cos(a)*v1))**2+(np.sin(a)/np.cos(a))*(t[k]-t[c])>0:
            L.append((-1/2)*g*(t[k]/(np.cos(a)*v1))**2+(np.sin(a)/np.cos(a))*t[k])
    return L
 
 
 
 
 
 
def tracefct(a,v):
    Y=sansfrottements(t,a,v)
    plt.figure(1)
    plt.plot(Y)
    plt.title("tracé d'une trajectoire sans frottements")
    plt.show()

Merci à tous

[lg_53]

Bonjour

Il manque la manière dont vous faites appel à vos fonctions...
J'ai essayé avec au hasard

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

tracefct(1,1)

Et en retour la liste est vide...


En attendant que vous répondiez à cette question pour que moi ou qqn d'autre puisse vous aider, je peux déjà commenter votre code :
- numpy c'est bien à utiliser dans ce genre de cas. Mais du coup traiter TOUS les tableaux comme ca serait bien. Plutot que d'écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
L=[]
for k in range(nbr):
    L.append(...)

Il est mieux d'écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
L=np.zeros(nbr)
for k in range(nbr):
    L[nbr]=...

Matplotlib fonctionnant avec numpy, c'est une raison de plus pour l'utiliser.

- Numpy est très puissant et en général permet d'éviter les boucles (vous faites les opérations sur les tableaux entiers directement). Il faut essayer d'utiliser cela aussi pour éclaircir le code (sans compter de multiples autres avantages comme la performance)

-

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
return L
print(L)

Là ca print rien du tout, vu que votre fonction arrive à la fin avant à cause du return. Il faut donc inverser ces 2 instructions si vous voulez voir qqch.

- Il y a des variables globales, d'autres qui sont passées en paramètres, d'autres qui sont un peu des deux (comme t par exemple). Il faudrait harmoniser tout ca.

- Eviter de calculer plusieurs fois la même chose. Par exemple si vous mettez

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    cos_a = np.cos(a)
    tan_a = np.sin(a)/cos_a  ### ou directement np.tan(a)

au début de votre fonction vous n'aurez pas à recalculer à chaque fois ces quantités.
De même, plutôt que d'écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
if blabla_long_calcul > 0 :
       L.append( blabla_long_calcul )

Ecrivez plutot :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
val = blabla_long_calcul ### qui ne sera calculer qu'une seule fois (et que vous n'écrirez qu'une fois aussi d'ailleurs)
if val > 0 :
       L.append( val )

[fifafou]

sinon,tu utilise un vecteur de vélocité horizontale,que tu décrémente et que t'inverse au rebonds,mais c'est pas aussi précis