Bonjour, je souhaitais savoir comment programmer en python un algorithme qui permet de résoudre un système d’équations différentielles d’ordre 2, à 2 inconnus, tel que présenter en pièce jointe. Je sais qu’il existe des modules comme odeint ou solve_ivp mais je galère. Merci
PS: le but est évidemment de déterminer les fonctions temporelles de r et thêta. G et Mt sont des constantes. Merci
Pour info, il existe aussi sympy.
Ensuite, il faut se mettre le nez dans la doc et les mains dans le cambouis.
On attend la suite...
Jusqu'ici tout va bien...
Bonjour, je suis arriver à cela, mais ca me donne un message d'erreur à la ligne 28, comme quoi je ne peux pas extraire un objet non itérable. Merci de l'aide
Le programme:
Code:from scipy.integrate import odeint import numpy as np from matplotlib import pyplot as plt t = np.linspace(0,25000,12500) #temps choisis pour simuler sur 4/5 orbites basses G = 6.67e-11 Mt = 5.97e24 def o(r): return (-G*Mt)/r #énergie potentielle gravitationelle def F(f,t): n = input("vitesse orthoradiale initiale en m/s: ") #conditions initiales m = input("altitude initiale par rapport à la surface en m: ") r0 = int(m) + 6371000 thetap0 = int(n)/r0 C = thetap0*(r0**2) f0 = [r0, 0, 0] [r, rp, theta] = f return [rp, (-G*Mt-((C**2)/r))/r**2, C/r**2] f = odeint(F, f0, t) r = f[:,0] theta = f[:,2] x = r*np.cos(theta) y = r*np.sin(theta) plt.plot(x,y) plt.show
Dernière modification par Jack ; 25/04/2022 à 09h35. Motif: Ajout balises code
Ton code n'appelle jamais la fonction F où le problème est supposé être. Pour l'appeler, il faut 2 paramètres : f dont on ne connait pas la valeur et t qui ne sert à rien.
Donc cela complique un peu la vie si on veut t'aider vu que ton problème est justement avec f.
Je me suis inspiré d'un code de ma prof de prépa. Et elle utilisait t pour définir le temps de simulation. Après j'appelle F dans la définition de f = odeint(F, f0, t]. Mais jsp c la première que je tente de résoudre ce genre d'équation par python
Non, ton code n'appelle jamais F si on le fait tourner.Envoyé par HSbF6
Quand à passer à une fonction dans son propre code donc récursivement, cela ne peut pas marcher dans ce cas puisque ça va partir en boucle sans fin.
Bonjour,
L'indentation est fausse, il faut mettre :
Enfin, il y d'autres erreurs, mais je laisse chercher.Code:from scipy.integrate import odeint import numpy as np from matplotlib import pyplot as plt t = np.linspace(0,25000,12500) #temps choisis pour simuler sur 4/5 orbites basses G = 6.67e-11 Mt = 5.97e24 def o(r): return (-G*Mt)/r #énergie potentielle gravitationelle def F(f,t): n = input("vitesse orthoradiale initiale en m/s: ") #conditions initiales m = input("altitude initiale par rapport à la surface en m: ") r0 = int(m) + 6371000 thetap0 = int(n)/r0 C = thetap0*(r0**2) [r, rp, theta] = f return [rp, (-G*Mt-((C**2)/r))/r**2, C/r**2] f0 = [r0, 0, 0] f = odeint(F, f0, t) r = f[:,0] theta = f[:,2] x = r*np.cos(theta) y = r*np.sin(theta) plt.plot(x,y) plt.show()
PS : il vaut mieux utiliser solve_ivp mais là ce n'est pas très important.
Dernière modification par Brinicle ; 25/04/2022 à 13h34.
Ne jamais faire un calcul sans connaître son résultat !
Oui mais même comme ça, on passe à odeint une fonction qui fait 2 "input" ce qui a peu de chance de fonctionner.
Oui, j'ai bien dit qu'il y avait d'autres erreurs, et ce n'est pas la seule, (entre autres, le fait qu'il y ait la condition initiale dans la fonction). ça se corrige assez vite, mais comme c'est un exercice, ce sera sans moi !Oui mais même comme ça, on passe à odeint une fonction qui fait 2 "input" ce qui a peu de chance de fonctionner.
J'avais fais un test avec cette indentation mais donc les input sont demandés dès la compilation du coup.
C'est pas vraiment un exercice. Dans un TD on devait trouver la trajectoire d'un satellite en orbite circulaire (en considérant r constant). La la résolution était simple. Mais j'ai voulu voir personnellement, si on pouvais résoudre cette équation avec r variable (donc pour tout type d'orbite). Donc je me suis lancé dans python en m'inspirant d'un programme de la prof pour trouver le profil temporel avec l'énergie potentiel, mais on a pas eu de cours sur les résolutions d'équa diff sur python. Je connais que odeint, après on verra.
Il n'y a pas de compilation en Python.
Quand on fait ctrl + entrée, c'est pas une compilation ?
Je ne sais pas ce que tu veux dire par "ctrl + entrée" vu que ça dépend non seulement de l'environnement que tu utilises mais aussi de sa configuration et de l'OS de la machine.
Mais non, par défaut, Python n'est pas compilé.
Ah oui c'est vrai. Je suis pas expert en informatique. C'est juste que ce système d'équation n'est pas résolvable analytiquement à notre niveau, alors il n'y avait plus que python. Mais notre prof d'info utilisait le terme de compilation alors je sais pas.
Ce qui n'est pas grave. Mais à cause de ça, tu nous donnes des informations partielles, ce qui est normal et comme je disais, c'est plus dur de t'aider.
Vu les efforts que tu fais, je vais te donner une base de code qui tourne.
Par contre, je ne suis pas du tout sur que les résultats soient corrects et notamment parce que j'ai plein de warning de la librairie odeint.
Code:from scipy.integrate import odeint import numpy as np from matplotlib import pyplot as plt t = np.linspace(0, 25000, 12500) # temps choisis pour simuler sur 4/5 orbites basses G = 6.67e-11 Mt = 5.97e24 def o(r): return (-G * Mt) / r # énergie potentielle gravitationelle def F(f, t): [r, rp, theta] = f return [rp, (-G * Mt - ((C ** 2) / r)) / r ** 2, C / r ** 2] n = input("vitesse orthoradiale initiale en m/s: ") # conditions initiales m = input("altitude initiale par rapport à la surface en m: ") r0 = int(m) + 6371000 thetap0 = int(n) / r0 C = thetap0 * (r0 ** 2) f0 = [r0, 0, 0] f = odeint(F, f0, t) r = f[:, 0] theta = f[:, 2] x = r * np.cos(theta) y = r * np.sin(theta) plt.plot(x, y) plt.show()
J'ai essayer exactement le même mais avec les conditions initiales au dessus de la fonction F, j'ai obtenu pareil. Mais ca sort une demi trajectoire avec des valeurs de x et y aberrante oui.
Puisque ce n'est pas un exercice...
La résolution est basée sur ces équations :
Qui est triviale.
Qui découle de la deuxième loi de Newton.
Qui est la conservation du moment cinétique.
Corrections faites :
Code:from scipy.integrate import odeint import numpy as np from matplotlib import pyplot as plt t = np.linspace(0, 25000, 12500) # temps choisis pour simuler sur 4/5 orbites basses G = 6.67e-11 Mt = 5.97e24 def F(f, t): [r, rp, theta] = f thetap = C /(r**2) return [rp,r*thetap**2-G*Mt/(r**2),thetap] n = input("vitesse orthoradiale initiale en m/s: ") # conditions initiales m = input("altitude initiale par rapport à la surface en m: ") r0 = float(m) + 6371000 thetap0 = float(n) / r0 C = thetap0 * (r0 ** 2) f0 = [r0,0, 0] f = odeint(F, f0, t) r = f[:, 0] theta = f[:, 2] x = r * np.cos(theta) y = r * np.sin(theta) plt.plot(x, y) plt.axis("equal") plt.show()
Ne jamais faire un calcul sans connaître son résultat !
Merci beaucoup, les trajectoires sont cohérentes. Je vais essayer d'afficher sur le graphique un cercle de la taille de la Terre, centré sur l'origine, pour rendre visible les orbites impossibles. Juste pour savoir, à quoi sert la commande plt.axis("equal") ? Sachant que j'ai remarqué que les échelles des axes n'étaient pas les mêmes.
Pense à consulter les docs officielles pour savoir ce que font les fonctions => https://matplotlib.org/3.5.0/api/_as...plot.axis.html
(dans l'interpréteur python aussi tu peux avoir l'aide via la commande help => help(plt.axis) (après import de pyplot as plt))
