'''Simulation du Stick-Slip - Code élèves'''

## Données physiques

k = 20 # N/m - Raideur du ressort
m = 1 # kg - Masse de la masse
fa = 0.2 # Coefficient d'adhérence
fg = 0.1 # Coefficient de glissement
mu = 1 # N/m/s - Viscosité
g = 9.81 # m/s² - Accélération de la pesanteur
vt = 0.05 # m/s - Vitesse du tapis

## Données numériques

P = m*g # kg - Poids de la masse
Ta = fa*P # N - Force tangentielle d'adhérence
Tg = fg*P # N - Force tangentielle à la limite du glissement
N = 1001 # Nombre de points de la résolution
tmax = 5.5 # s - Temps de fin de simulation
dt = tmax/(N-1) # s - Pas de temps
x0 = 0 # m - Position initiale de la masse
xp0 = vt # m/s - Vitesse initiale de la masse
import numpy as np
V = np.array([x0,xp0]) # Vecteur V initial
t = 0 # s - Temps initial
i = 0 # Pas de temps initial

## Initialisation des listes

Lt = [t] # Liste des temps
Lx = [x0] # Liste des positions de la masse
Lv = [xp0] # Liste des vitesses de la masse
Lvt = [vt] # Liste des vitesses du tapis (constante)
Lvr = [0] # Liste des vitesses relatives Masse/Tapis
LT = [0] # Liste des efforts tangentiels au contact Tapis -> Masse
LFk = [0] # Liste des efforts du ressort

## Fonctions

def f(V):
    '''
    A compléter
    '''

def F(V):
    '''
    A compléter
    '''

def New_V(F,V):
    '''
    A compléter
    '''

def sign(x):
    '''
    A compléter
    '''

## Résolution

while t < tmax:
    break
    '''
    A compléter
    Doit remplir les listes Lt Lx Lv Lvt Lvr LT LKk
    '''

## Affichage courbes

import matplotlib.pyplot as plt
plt.close('all')

def Affiche(X,Y,fig):
    plt.figure(fig)
    plt.plot(X,Y)
    plt.show()

Affiche(Lt,Lx,1)
Affiche(Lt,Lvt,2)
Affiche(Lt,Lv,2)
Affiche(Lt,Lvr,3)
Affiche(Lt,LT,4)
Affiche(Lt,LFk,4)

## Affichage simulation

Xmin = min(Lx)
Xmax = max(Lx)
Course = Xmax - Xmin
N = 50 # Nombre de petits carrés théorique
Dx = Dy = Course/(2*N) # Taille petits carrés
Cx = Cy = 5*Dy # Taille grand carré
y = Cy/2 # Ordonnée centre grand carré
Xmin_aff = Xmin - Cx
Xmax_aff = Xmax + Cx
Course_aff = Xmax_aff - Xmin_aff
Ymin_aff = -Dy
Ymax_aff = 2*y

Fkmax = max(LFk)

tmax = max(Lt)
N_tapis = int(Course_aff/(2*Dx))+1 # Nombre réel de petits carrés
Lx_Tapis = [Xmin+2*i*Dx for i in range(N_tapis)]

LTa = [Ta for i in range(len(Lt))]
LTg = [Tg for i in range(len(Lt))]
LTam = [-Ta for i in range(len(Lt))]
LTgm = [-Tg for i in range(len(Lt))]

def Rectangle(x,y,dx,dy,col):
    xg = x - dx/2
    xd = x + dx/2
    yb = y - dy/2
    yh = y + dy/2
    Liste_X = [xg,xd,xd,xg,xg]
    Liste_Y = [yb,yb,yh,yh,yb]
    plt.fill(Liste_X,Liste_Y,col)

def Tapis(L):
    for x in L:
        Rectangle(x,-Dy/2,Dx,Dy,'k')

def Masse(x,vr):
    if abs(vr) < vt/10:
        col = 'r'
    else:
        col = 'orange'
    Rectangle(x,y,Cx,Cy,col)
    plt.axis('scaled')
    plt.xlim([Xmin_aff,Xmax_aff])
    plt.ylim([Ymin_aff,Ymax_aff])

def Ressort(x):
    e = 20*(Xmax - x)/Xmax
    plt.plot([0,x],[y,y],'k',linewidth = e,zorder=1)

def Force_Tangentielle(x,T):
    T_aff = Cx*T/Ta
    plt.arrow(x,0,T_aff,0,color='b',head_length=Cx/5,zorder=2)

def Force_Ressort(x,T):
    T_aff = Cx*T/Ta
    plt.arrow(x,y,T_aff,0,color='g',head_length=Cx/5,zorder=2)

def MAJ_Tapis():
    global Lx_Tapis # Pour pouvoir modifier
    for i in range(len(Lx_Tapis)):
        x = Lx_Tapis[i]
        x += vt*dt
        if x > Xmax_aff:
            x -= Course_aff
        Lx_Tapis[i] = x

def Animation(x,vr,T,Fk,pos):
    plt.subplot(pos)
    Masse(x,vr)
    MAJ_Tapis()
    Tapis(Lx_Tapis)
    Ressort(x)
    Force_Tangentielle(x,T)
    Force_Ressort(x,Fk)

def Graphe_Pt(Lx,Ly,i,leg,pos,Col):
    plt.subplot(pos)
    plt.plot(Lx,Ly,label=leg,color=Col)
    plt.plot(Lx[i],Ly[i],'ro')
    plt.legend()

def Graphe(Lx,Ly,pos):
    plt.subplot(pos)
    plt.plot(Lx,Ly,'--k')

plt.figure(5,figsize=(20,10))
for i in range(len(Lx)):
    x = Lx[i]
    t = Lt[i]
    vr = Lvr[i]
    T = LT[i]
    Fk = LFk[i]
    plt.clf()
    Graphe_Pt(Lt,Lx,i,'x',321,'k')
    Graphe_Pt(Lt,Lv,i,'v',322,'k')
    Graphe_Pt(Lt,Lvr,i,'vr',323,'k')
    Graphe_Pt(Lt,LT,i,'T',324,'b')
    Graphe_Pt(Lt,LFk,i,'Fk',324,'g')
    Graphe(Lt,LTa,324)
    Graphe(Lt,LTg,324)
    Graphe(Lt,LTam,324)
    Graphe(Lt,LTgm,324)
    Animation(x,vr,T,Fk,313)
    plt.show()
    plt.savefig("Images\\"+str(i)+".jpg")
    plt.pause(0.01)