# -*- coding: utf-8 -*-
# Created on Thu Sep 12 08:15:00 2024
# @author: mhebding
# TP4 - Methodes numeriques



## 1 - Preparation

# 0.
# import et variables globales

# 1.
pointage = np.loadtxt("pointage.txt",skiprows=1) # A COMMENTER
Xexp = pointage[:,5] # A COMMENTER
Yexp = pointage[:,6] # A COMMENTER
#plt.figure('Donnees experimentales')
#plt.plot(Xexp,Yexp, 'o', label='Donnees brutes')
#plt.legend()
x = Xexp - Xexp [0] # A COMMENTER
y = -(Yexp - Yexp[0]) # A COMMENTER

# 2.
def exp():
    return None # a ecrire pour afficher la trajectoire experimentale

#exp()



## 2 - Modelisation

"""
# ecrire les resultats theoriques ici
"""

# 3.
None # a completer
# Vxlim = 
# Vylim =
# Vlim = 
#print('Vlim= '+str(round(Vlim,3))) # valeur de l'auteur 6.7 m/s

# a = 
# b = 

# 4.
None # a completer
# Vx0 = 
# Vy0 = 
# V0 = 
#print('V0= '+str(round(V0,3))) # valeur de l'auteur 40 m/s



## 3 - Methode d'Euler

# 5.
def A_lin(Vx,Vy):
    return None # a ecrire

def A_quad(Vx,Vy):
    return None # a ecrire

# 6.
dt = Te/50 # pas
N  = int((Te/dt)*len(x)) # nombre de points

def euler_V(acceleration):
    t = 0 # initialisations
    Vx = Vx0
    Vy = Vy0
    liste_t = [t]
    liste_Vx = [Vx]
    liste_Vy = [Vy]
    for n in range(N):
        None # a completer
    return liste_t, liste_Vx, liste_Vy

# 7.
def euler_OM(Vx,Vy):
    x = 0
    y = 0
    liste_X = [x]
    liste_Y = [y]
    for n in range(len(Vx)): 
        None # a completer
    return liste_X, liste_Y

# 8.
None # a ecrire pour calculer t, Vx_lin, Vy_lin
None # a ecrire pour calculer X_lin, Y_lin

None # a ecrire pour calculer t, Vx_quad, Vy_quad
None # a ecrire pour calculer t, X_quad, Y_quad

def comparaison():
    return None # a ecrire pour afficher la trajectoire experimentale et les deux modeles

#comparaison()

# 9.
def auteur():
    return None # a completer
# V0 = 
# Vx0 = 
# Vy0 = 
    comparaison()

#auteur()



## 4 - Resolution avec une bibliotheque

# 10.
"""
Cinem est un tableau numpy (= une liste de listes) qui contient les vecteurs cinematiques du volant a l instant t.
Cinem[0] = liste des x(t)
Cinem[1] = liste des y(t)
Cinem[2] = liste des Vx(t)
Cinem[3] = liste des Vy(t)

DerivC est une fonction qui, connaissant Cinem a l instant t renvoie sa derivee (idem methode d Euler).
"""

def DerivC(Cinem,t): # prends X, Y, Vx, Vy
    Ax, Ay = A_quad(Cinem[2],Cinem[3])
    return [Cinem[2],Cinem[3], Ax, Ay] # retourne Vx, Vy, Ax, Ay

t = np.linspace(0,Te*len(x),N)
Cinem = odeint(DerivC,[0,0,Vx0,Vy0],t)
X_odeint = Cinem[:,0]
Y_odeint = Cinem[:,1]

def exp_euler_odeint():
    return None # instructions pour graphes exp, euler et odeint

#exp_euler_odeint()