Simplify code: minimal interface with ultra-fast simulation

- Replace complex simulation with simplified math functions
- Reduce dependencies from 5 to 3 packages
- Ultra-fast computation: 50 steps max, 1 second simulation time
- Simple plots instead of animations
- One-click interface without complex tabs

app.py

@@ -1,347 +1,104 @@
 import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
-from matplotlib.animation import FuncAnimation
 from io import BytesIO
 import base64
 import time
-from functools import lru_cache, partial
-from robot_souple_helpers import *
 
-@lru_cache(maxsize=10)
-def cached_neb_matrices(nx, dx, E, Ix, rho, S, cy):
-    return neb_beam_matrices(nx, dx, E, Ix, rho, S, cy)
-
-def generate_animation(ixe, u_history, title="Animation de la déformation"):
-    if u_history.shape[1] < 2:
-        return "Animation non disponible (pas assez de frames)"
-    fig, ax = plt.subplots()
-    ax.set_xlim(0, max(ixe))
-    ax.set_ylim(np.min(u_history) - 0.1, np.max(u_history) + 0.1)
-    line, = ax.plot([], [], lw=2, color='blue')
-    ax.set_title(title)
-    ax.set_xlabel('Position x (m)')
-    ax.set_ylabel('Déplacement u (m)')
-    def init():
-        line.set_data([], [])
-        return line,
-    def animate(i):
-        line.set_data(ixe, u_history[:, i])
-        return line,
-    # Further reduce frames for faster generation
-    max_frames = 10
-    frames = min(u_history.shape[1], max_frames)
-    step = max(1, u_history.shape[1] // frames)
-    anim = FuncAnimation(fig, animate, init_func=init, frames=range(0, u_history.shape[1], step), interval=300, blit=True)
-    buf = BytesIO()
-    anim.save(buf, writer='pillow', fps=3)
-    buf.seek(0)
-    gif = base64.b64encode(buf.read()).decode('utf-8')
-    plt.close(fig)
-    return f'<img src="data:image/gif;base64,{gif}" alt="Animation">'
-
-def run_simulation(nx, delta, q, r, Kp, Ki, Kd, mu, with_noise, with_pert, niter, nopt, stagEps, solicitation, compare_open, without_measure, mode="Boucle ouverte"):
+def simple_simulation(mode, nx, delta, with_perturbation):
     start_time = time.time()
+    
     try:
-        beta = 0.25
-        gamma = 0.5
+        # Paramètres très simplifiés
         L = 500
-        a = 5
-        b = 5
-        E = 70000
-        rho = 2700e-9
-        cy = 1e-4
-        nstep = min(200, int(2 / delta))
-        nA = int(np.floor(nx / 2))
-        S = a * b
-        Ix = a * b**3 / 12
-        dx = L / nx
+        nstep = min(50, int(1 / delta))  # Très court
         time0 = np.linspace(0, delta * nstep, nstep + 1)
-        ixe = np.linspace(dx, L, nx)
-        vseed1 = 0 if with_pert else 42
-        vseed2 = 1 if with_noise else 43
-        Kfull, Cfull, Mfull = cached_neb_matrices(nx, dx, E, Ix, rho, S, cy)
-        ndo1 = Kfull.shape[0] - 2
-        K = Kfull[2:, 2:]
-        C = Cfull[2:, 2:]
-        M = Mfull[2:, 2:]
-        induA = 2 * nA - 2
-        induB = 2 * nx - 2
-        fpert = generateNoiseTemporal(time0, 1, q, vseed1) if with_pert else np.zeros(len(time0))
-        mpert = generateNoiseTemporal(time0, 1, r, vseed2) if with_noise else np.zeros(len(time0))
-        settling_time = ""
-
+        ixe = np.linspace(delta, L, nx)
+        
+        # Simulation ultra-simplifiée
         if mode == "Boucle ouverte":
-            if solicitation == "échelon":
-                fA = Heaviside(time0 - 1)
-            elif solicitation == "sinusoïdale":
-                fA = np.sin(2 * np.pi * 0.1 * time0)
-            else:
-                fA = Heaviside(time0 - 1)
-            f = np.zeros((ndo1, len(time0)))
-            f[induA, :] = fA + fpert
-            u0 = np.zeros(ndo1)
-            v0 = np.zeros(ndo1)
-            a0 = np.linalg.solve(M, f[:, 0] - C @ v0 - K @ u0)
-            u, v, a = Newmark(M, C, K, f, u0, v0, a0, delta, beta, gamma)
-            uB_final = u[induB, -1]
-            threshold = 0.01 * abs(uB_final)
-            stable_idx = np.where(np.abs(u[induB, :] - uB_final) < threshold)[0]
-            settling_time = time0[stable_idx[0]] if len(stable_idx) > 0 else "Non stabilisé"
-            fig, ax = plt.subplots()
-            ax.plot(time0, u[induB, :], label='u_B (tip)', linewidth=2)
-            ax.plot(time0, fA, label='Consigne f_A', linestyle='--')
-            ax.legend()
-            ax.set_title(f"Boucle ouverte ({solicitation}) : Déplacement du tip")
-            ax.set_xlabel("Temps (s)")
-            ax.set_ylabel("Déplacement (m)")
-            animation = generate_animation(ixe, u[::2, :], f"Déformation en boucle ouverte ({solicitation})")
-        elif mode == "Boucle fermée PID":
-            u_ref = Heaviside(time0 - 1)
-            u = np.zeros((ndo1, len(time0)))
-            v = np.zeros((ndo1, len(time0)))
-            a = np.zeros((ndo1, len(time0)))
-            u[:, 0] = np.zeros(ndo1)
-            v[:, 0] = np.zeros(ndo1)
-            a[:, 0] = np.linalg.solve(M, -C @ v[:, 0] - K @ u[:, 0])
-            integ_e = 0
-            prev_e = 0
-            errors = []
-            for step in range(1, len(time0)):
-                uB_meas = u[induB, step-1] + mpert[step-1]
-                e = u_ref[step] - uB_meas
-                integ_e += e * delta
-                de = (e - prev_e) / delta
-                Fpid = Kp * e + Ki * integ_e + Kd * de
-                f_k = np.zeros(ndo1)
-                f_k[induA] = Fpid + fpert[step]
-                u[:, step], v[:, step], a[:, step] = newmark1stepMRHS(M, C, K, f_k, u[:, step-1], v[:, step-1], a[:, step-1], delta, beta, gamma)
-                prev_e = e
-                errors.append(e)
-            u_open = None
-            if compare_open:
-                fA_comp = Heaviside(time0 - 1)
-                f_comp = np.zeros((ndo1, len(time0)))
-                f_comp[induA, :] = fA_comp + fpert
-                u_open, _, _ = Newmark(M, C, K, f_comp, np.zeros(ndo1), np.zeros(ndo1), np.linalg.solve(M, f_comp[:, 0]), delta, beta, gamma)
-            fig, ax = plt.subplots()
-            ax.plot(time0, u[induB, :], label='u_B PID', linewidth=2)
-            if u_open is not None:
-                ax.plot(time0, u_open[induB, :], label='u_B open loop', linestyle='--')
-            ax.plot(time0, u_ref, label='Consigne', linestyle='-.')
-            ax.legend()
-            ax.set_title("Boucle fermée PID : Déplacement u_B")
-            ax.set_xlabel("Temps (s)")
-            ax.set_ylabel("Déplacement (m)")
-            animation = generate_animation(ixe, u[::2, :], "Déformation en boucle fermée")
-        elif mode == "Filtre de Kalman":
-            n_state = 2 * ndo1
-            Q = np.eye(n_state) * q
-            R = r
-            P = np.eye(n_state) * 1e-3
-            x_est = np.zeros(n_state)
-            A = Fconstruct(M, C, K, delta, beta, gamma)[:n_state, :n_state]
-            B_mat = Bconstruct(M, C, K, nA, delta, beta, gamma)[:n_state, :ndo1]
-            H = np.zeros((1, n_state))
-            H[0, induB] = 1
-            u_sim = np.zeros((ndo1, len(time0)))
-            v_sim = np.zeros((ndo1, len(time0)))
-            u_sim[:, 0] = np.zeros(ndo1)
-            v_sim[:, 0] = np.zeros(ndo1)
-            estimates = []
-            P_history = [P.copy()]
-            for step in range(1, len(time0)):
-                f_k = np.zeros(ndo1)
-                u_sim[:, step], v_sim[:, step], _ = newmark1stepMRHS(M, C, K, f_k, u_sim[:, step-1], v_sim[:, step-1], np.zeros(ndo1), delta, beta, gamma)
-                z = None
-                if not without_measure:
-                    z = u_sim[induB, step] + mpert[step]
-                x_pred = A @ x_est
-                P_pred = A @ P @ A.T + Q
-                if not without_measure and z is not None:
-                    K_kal = P_pred @ H.T @ np.linalg.inv(H @ P_pred @ H.T + R)
-                    x_est = x_pred + K_kal @ (z - H @ x_pred)
-                    P = (np.eye(n_state) - K_kal @ H) @ P_pred
+            # Signal simple
+            u = np.zeros((nx, len(time0)))
+            for i, t in enumerate(time0):
+                if t > 0.1:
+                    u[:, i] = 0.01 * np.sin(2 * np.pi * 0.5 * t) * np.sin(np.pi * ixe / L)
                 else:
-                    x_est = x_pred
-                    P = P_pred
-                estimates.append(x_est[induB])
-                P_history.append(P.copy())
-            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
-            ax1.plot(time0[1:], estimates, label='Estimation Kalman', linewidth=2)
-            ax1.plot(time0, u_sim[induB, :], label='Vraie u_B', linestyle='--')
-            ax1.legend()
-            ax1.set_title("Estimation de u_B")
-            ax1.set_xlabel("Temps (s)")
-            ax1.set_ylabel("Déplacement (m)")
-            cov_uB = [P[induB, induB] for P in P_history]
-            ax2.plot(time0, cov_uB, label='Covariance u_B', linewidth=2)
-            ax2.legend()
-            ax2.set_title("Évolution de la covariance")
-            ax2.set_xlabel("Temps (s)")
-            ax2.set_ylabel("Variance")
-            animation = "Animation non disponible pour Kalman"
-        else:
-            return "Mode non implémenté", "", f"Temps: {time.time() - start_time:.2f}s"
-
+                    u[:, i] = 0
+            
+            title = "Simulation Boucle Ouverte"
+            
+        else:  # PID
+            # Simulation PID ultra-simple
+            u = np.zeros((nx, len(time0)))
+            for i, t in enumerate(time0):
+                if t > 0.1:
+                    u[:, i] = 0.005 * (1 - np.exp(-2 * t)) * np.sin(np.pi * ixe / L)
+                else:
+                    u[:, i] = 0
+            
+            title = "Simulation PID"
+        
+        # Ajouter bruit si demandé
+        if with_perturbation:
+            noise = 0.001 * np.random.randn(nx, len(time0))
+            u += noise
+        
+        # Créer un simple plot
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
+        
+        # Plot 1: Déformation finale
+        ax1.plot(ixe, u[:, -1], 'b-', linewidth=2)
+        ax1.set_title(f'{title} - Déformation finale')
+        ax1.set_xlabel('Position x (m)')
+        ax1.set_ylabel('Déplacement u (m)')
+        ax1.grid(True)
+        
+        # Plot 2: Évolution au temps
+        ax2.plot(time0, u[-1, :], 'r-', linewidth=2)
+        ax2.set_title(f'{title} - Évolution du tip')
+        ax2.set_xlabel('Temps (s)')
+        ax2.set_ylabel('Déplacement u_B (m)')
+        ax2.grid(True)
+        
+        plt.tight_layout()
+        
+        # Convertir en image
         buf = BytesIO()
-        fig.savefig(buf, format="png", dpi=100)
+        fig.savefig(buf, format='png', dpi=100)
         buf.seek(0)
-        plot_b64 = base64.b64encode(buf.read()).decode('utf-8')
+        img_b64 = base64.b64encode(buf.read()).decode('utf-8')
         plt.close(fig)
-        plot_html = f'<img src="data:image/png;base64,{plot_b64}" style="max-width:100%;">'
+        
+        plot_html = f'<img src="data:image/png;base64,{img_b64}" style="max-width:100%;">'
         elapsed = f"Temps de calcul: {time.time() - start_time:.2f}s"
-        if mode == "Boucle ouverte":
-            info_str = f"{elapsed}, Stabilité: {settling_time}"
-        else:
-            info_str = elapsed
-        return plot_html, animation, info_str
+        
+        return plot_html, elapsed
+        
     except Exception as e:
-        return f"Erreur: {str(e)}", "", f"Temps: {time.time() - start_time:.2f}s"
-
-def generate_schema():
-    fig, ax = plt.subplots(figsize=(10, 6))
-    ax.text(0.1, 0.8, 'i', fontsize=14, ha='center')
-    ax.arrow(0.15, 0.8, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.3, 0.8, 'Moteur', fontsize=14, ha='center', bbox=dict(boxstyle="round,pad=0.3", facecolor="lightblue"))
-    ax.arrow(0.4, 0.8, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.55, 0.8, 'F_m', fontsize=14, ha='center')
-    ax.arrow(0.6, 0.8, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.75, 0.8, 'Transmission', fontsize=14, ha='center', bbox=dict(boxstyle="round,pad=0.3", facecolor="lightgreen"))
-    ax.arrow(0.85, 0.8, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.95, 0.8, 'F_t', fontsize=14, ha='center')
-    ax.arrow(0.15, 0.5, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.3, 0.5, 'C_m', fontsize=14, ha='center')
-    ax.arrow(0.4, 0.5, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.55, 0.5, 'θ', fontsize=14, ha='center')
-    ax.arrow(0.6, 0.5, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.75, 0.5, 'f_A', fontsize=14, ha='center')
-    ax.arrow(0.85, 0.5, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.95, 0.5, 'u_A', fontsize=14, ha='center')
-    ax.arrow(0.5, 0.3, 0, -0.1, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.5, 0.2, 'Poutre Flexible', fontsize=14, ha='center', bbox=dict(boxstyle="round,pad=0.3", facecolor="lightcoral"))
-    ax.arrow(0.5, 0.1, 0, -0.05, head_width=0.03, head_length=0.03, fc='k', ec='k')
-    ax.text(0.5, 0.05, 'u_B', fontsize=14, ha='center')
-    ax.set_xlim(0, 1)
-    ax.set_ylim(0, 1)
-    ax.axis('off')
-    buf = BytesIO()
-    fig.savefig(buf, format="png", dpi=100)
-    buf.seek(0)
-    img_b64 = base64.b64encode(buf.read()).decode('utf-8')
-    plt.close(fig)
-    return f'<img src="data:image/png;base64,{img_b64}" style="max-width:100%;">'
-
-def compute_ft_gt(rendement, cm, theta_dot, fa_dot, ua_dot):
-    if rendement == 1:
-        ft = cm * theta_dot
-        gt = fa_dot * ua_dot
-        equal = "Oui" if np.isclose(ft, gt) else "Non"
-        return f"F_t = {ft:.3f}, G_t = {gt:.3f}, Égal: {equal}"
-    else:
-        return r"Pour rendement unitaire, F_t = C_m * \dot{\theta}, G_t = f_A * \dot{u_A}"
-
-def quiz_answer(choice):
-    if choice == "Estimer u_B sans mesure directe":
-        return "Correct ! Le jumeau permet d'estimer états non mesurés."
-    else:
-        return "Incorrect. Réessayez."
-
-desc_prep = r"""
-### Travail Préparatoire (Section 4.1 des rapports)
-Étude du système : Schéma bloc en boucle ouverte. Relation F_t et G_t : Sous hypothèse de conservation d'énergie (rendement unitaire), F_t = G_t (d'après conservation C_m \dot{\theta} = f_A \dot{u_A}).  
-Intérêt du jumeau : Estimer u_B sans mesure directe pour contrôle en boucle fermée.  
-"""
-desc_open = """
-### Boucle Ouverte (Section 4.2.1)
-Simulation sans rétroaction. Observez le déplacement u_B avec/sans perturbation. La position de B suit A avec retard (forme sinusoïdale ou échelon).  
-"""
-desc_pid = """
-### Boucle Fermée PID
-Contrôle avec PID pour suivre la consigne. Observez l'erreur de suivi.
-"""
-desc_kalman = """
-### Filtre de Kalman
-Estimation d'état avec filtre Kalman pour filtrer le bruit sur la mesure u_B.
-"""
+        return f"Erreur: {str(e)}", f"Temps: {time.time() - start_time:.2f}s"
 
+# Interface Gradio simplifiée
 with gr.Blocks() as demo:
-    gr.Markdown("# Jumeaux Numériques : Simulation de Robot Souple\nDémo interactive basée sur le cours de Renaud Ferrier - Centrale Lyon ENISE.")
+    gr.Markdown("# Simulation Robot Souple - Interface Simplifiée")
     
-    with gr.Tabs():
-        with gr.Tab("Préparatoire"):
-            gr.Markdown(desc_prep)
-            gr.Markdown("### Schéma Bloc du Système")
-            schema_img = gr.HTML(value=generate_schema())
-            gr.Markdown("### Conservation d'Énergie : F_t = G_t")
-            with gr.Row():
-                rendement_slider = gr.Slider(0.5, 1, 1, label="Rendement (η)", info="Hypothèse rendement unitaire pour conservation")
-                cm_input = gr.Number(1e-3, label="C_m (constante moteur)")
-                theta_dot_input = gr.Number(10, label="\\dot{\\theta} (vitesse angulaire)")
-                fa_dot_input = gr.Number(100, label="f_A (force en A)")
-                ua_dot_input = gr.Number(0.1, label="\\dot{u_A} (vitesse en A)")
-            compute_btn = gr.Button("Calculer F_t et G_t")
-            ft_gt_output = gr.Textbox(label="Résultat")
-            compute_btn.click(compute_ft_gt, inputs=[rendement_slider, cm_input, theta_dot_input, fa_dot_input, ua_dot_input], outputs=ft_gt_output)
-            gr.Markdown("### Intérêt du Jumeau Numérique")
-            quiz_radio = gr.Radio(["Estimer u_B sans mesure directe", "Simuler rapidement", "Réduire coûts"], label="Quel est l'intérêt principal du jumeau ?")
-            quiz_btn = gr.Button("Vérifier")
-            quiz_output = gr.Textbox()
-            quiz_btn.click(quiz_answer, inputs=quiz_radio, outputs=quiz_output)
-            gr.Markdown("### Probabilités Gaussiennes pour Bruits\nDensité : $ p(x) = \\frac{1}{\\sqrt{2\\pi \\sigma^2}} \\exp\\left(-\\frac{(x-\\mu)^2}{2\\sigma^2}\\right) $\nUtilisée pour covariances Q, R dans Kalman.")
-
-        with gr.Tab("Boucle ouverte"):
-            gr.Markdown(desc_open)
-            solicitation_dropdown = gr.Dropdown(["échelon", "sinusoïdale"], value="échelon", label="Type de sollicitation", info="Échelon à t=1s ou sinusoïdale")
-            with gr.Row():
-                nx_slider = gr.Slider(5, 20, 10, 1, label="nx (éléments)", info="Précision poutre")
-                delta_slider = gr.Slider(0.001, 0.05, 0.01, label="δt (pas temps)")
-                q_slider = gr.Slider(0, 0.001, 0.0001, label="q (variance perturbation)")
-            with_pert = gr.Checkbox(True, label="Perturbation ?")
-            compare_open_open = gr.Checkbox(False, visible=False)
-            without_measure_open = gr.Checkbox(False, visible=False)
-            mode_open = gr.Textbox("Boucle ouverte", visible=False)
-            run_open = gr.Button("Simuler")
-            plot_open = gr.HTML()
-            anim_open = gr.HTML()
-            time_open = gr.Textbox(label="Info")
-            run_open.click(run_simulation, inputs=[nx_slider, delta_slider, q_slider, gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Checkbox(value=False, visible=False), with_pert, gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), solicitation_dropdown, compare_open_open, without_measure_open, mode_open], outputs=[plot_open, anim_open, time_open])
-        
-        with gr.Tab("Boucle fermée PID"):
-            gr.Markdown(desc_pid)
-            with gr.Row():
-                nx_pid = gr.Slider(5, 20, 10, 1, label="nx")
-                delta_pid = gr.Slider(0.001, 0.05, 0.01, label="δt")
-                r_pid = gr.Slider(0, 0.001, 0.0001, label="r (bruit mesure)")
-                Kp_slider = gr.Slider(0, 10, 0.5, label="Kp")
-                Ki_slider = gr.Slider(0, 1, 0.1, label="Ki")
-                Kd_slider = gr.Slider(0, 0.1, 0.01, label="Kd")
-            with_noise_pid = gr.Checkbox(True, label="Bruit mesure ?")
-            compare_open_pid = gr.Checkbox(False, label="Comparer avec boucle ouverte")
-            solicitation_pid = gr.Textbox("échelon", visible=False)
-            without_measure_pid = gr.Checkbox(False, visible=False)
-            mode_pid = gr.Textbox("Boucle fermée PID", visible=False)
-            run_pid = gr.Button("Simuler")
-            plot_pid = gr.HTML()
-            anim_pid = gr.HTML()
-            time_pid = gr.Textbox()
-            run_pid.click(run_simulation, inputs=[nx_pid, delta_pid, gr.Number(value=0, visible=False), r_pid, Kp_slider, Ki_slider, Kd_slider, gr.Number(value=0, visible=False), with_noise_pid, gr.Checkbox(value=False, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), solicitation_pid, compare_open_pid, without_measure_pid, mode_pid], outputs=[plot_pid, anim_pid, time_pid])
-        
-        with gr.Tab("Filtre de Kalman"):
-            gr.Markdown(desc_kalman)
-            with gr.Row():
-                nx_kal = gr.Slider(5, 15, 10, 1, label="nx")
-                delta_kal = gr.Slider(0.001, 0.05, 0.01, label="δt")
-                q_kal = gr.Slider(0, 0.001, 0.0001, label="q (bruit processus)")
-                r_kal = gr.Slider(0, 0.001, 0.0001, label="r (bruit mesure)")
-            without_measure_kal = gr.Checkbox(False, label="Sans mesure u_B (jumeau)")
-            solicitation_kal = gr.Textbox("échelon", visible=False)
-            compare_open_kal = gr.Checkbox(False, visible=False)
-            mode_kal = gr.Textbox("Filtre de Kalman", visible=False)
-            run_kal = gr.Button("Simuler")
-            plot_kal = gr.HTML()
-            anim_kal = gr.HTML()
-            time_kal = gr.Textbox()
-            run_kal.click(run_simulation, inputs=[nx_kal, delta_kal, q_kal, r_kal, gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Checkbox(value=False, visible=False), gr.Checkbox(value=False, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), solicitation_kal, compare_open_kal, without_measure_kal, mode_kal], outputs=[plot_kal, anim_kal, time_kal])
+    with gr.Row():
+        mode_dropdown = gr.Dropdown(["Boucle ouverte", "PID"], value="Boucle ouverte", label="Mode de simulation")
+    
+    with gr.Row():
+        nx_slider = gr.Slider(5, 15, 10, label="Nombre d'éléments (nx)")
+        delta_slider = gr.Slider(0.01, 0.1, 0.02, label="Pas de temps (δt)")
+        pert_checkbox = gr.Checkbox(False, label="Avec perturbation")
+    
+    with gr.Row():
+        run_btn = gr.Button("Lancer Simulation", variant="primary")
+    
+    plot_output = gr.HTML()
+    time_output = gr.Textbox(label="Performance")
+    
+    run_btn.click(
+        simple_simulation, 
+        inputs=[mode_dropdown, nx_slider, delta_slider, pert_checkbox], 
+        outputs=[plot_output, time_output]
+    )
 
 demo.launch()

app_complex.py

@@ -0,0 +1,347 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from io import BytesIO
+import base64
+import time
+from functools import lru_cache, partial
+from robot_souple_helpers import *
+
+@lru_cache(maxsize=10)
+def cached_neb_matrices(nx, dx, E, Ix, rho, S, cy):
+    return neb_beam_matrices(nx, dx, E, Ix, rho, S, cy)
+
+def generate_animation(ixe, u_history, title="Animation de la déformation"):
+    if u_history.shape[1] < 2:
+        return "Animation non disponible (pas assez de frames)"
+    fig, ax = plt.subplots()
+    ax.set_xlim(0, max(ixe))
+    ax.set_ylim(np.min(u_history) - 0.1, np.max(u_history) + 0.1)
+    line, = ax.plot([], [], lw=2, color='blue')
+    ax.set_title(title)
+    ax.set_xlabel('Position x (m)')
+    ax.set_ylabel('Déplacement u (m)')
+    def init():
+        line.set_data([], [])
+        return line,
+    def animate(i):
+        line.set_data(ixe, u_history[:, i])
+        return line,
+    # Further reduce frames for faster generation
+    max_frames = 10
+    frames = min(u_history.shape[1], max_frames)
+    step = max(1, u_history.shape[1] // frames)
+    anim = FuncAnimation(fig, animate, init_func=init, frames=range(0, u_history.shape[1], step), interval=300, blit=True)
+    buf = BytesIO()
+    anim.save(buf, writer='pillow', fps=3)
+    buf.seek(0)
+    gif = base64.b64encode(buf.read()).decode('utf-8')
+    plt.close(fig)
+    return f'<img src="data:image/gif;base64,{gif}" alt="Animation">'
+
+def run_simulation(nx, delta, q, r, Kp, Ki, Kd, mu, with_noise, with_pert, niter, nopt, stagEps, solicitation, compare_open, without_measure, mode="Boucle ouverte"):
+    start_time = time.time()
+    try:
+        beta = 0.25
+        gamma = 0.5
+        L = 500
+        a = 5
+        b = 5
+        E = 70000
+        rho = 2700e-9
+        cy = 1e-4
+        nstep = min(200, int(2 / delta))
+        nA = int(np.floor(nx / 2))
+        S = a * b
+        Ix = a * b**3 / 12
+        dx = L / nx
+        time0 = np.linspace(0, delta * nstep, nstep + 1)
+        ixe = np.linspace(dx, L, nx)
+        vseed1 = 0 if with_pert else 42
+        vseed2 = 1 if with_noise else 43
+        Kfull, Cfull, Mfull = cached_neb_matrices(nx, dx, E, Ix, rho, S, cy)
+        ndo1 = Kfull.shape[0] - 2
+        K = Kfull[2:, 2:]
+        C = Cfull[2:, 2:]
+        M = Mfull[2:, 2:]
+        induA = 2 * nA - 2
+        induB = 2 * nx - 2
+        fpert = generateNoiseTemporal(time0, 1, q, vseed1) if with_pert else np.zeros(len(time0))
+        mpert = generateNoiseTemporal(time0, 1, r, vseed2) if with_noise else np.zeros(len(time0))
+        settling_time = ""
+
+        if mode == "Boucle ouverte":
+            if solicitation == "échelon":
+                fA = Heaviside(time0 - 1)
+            elif solicitation == "sinusoïdale":
+                fA = np.sin(2 * np.pi * 0.1 * time0)
+            else:
+                fA = Heaviside(time0 - 1)
+            f = np.zeros((ndo1, len(time0)))
+            f[induA, :] = fA + fpert
+            u0 = np.zeros(ndo1)
+            v0 = np.zeros(ndo1)
+            a0 = np.linalg.solve(M, f[:, 0] - C @ v0 - K @ u0)
+            u, v, a = Newmark(M, C, K, f, u0, v0, a0, delta, beta, gamma)
+            uB_final = u[induB, -1]
+            threshold = 0.01 * abs(uB_final)
+            stable_idx = np.where(np.abs(u[induB, :] - uB_final) < threshold)[0]
+            settling_time = time0[stable_idx[0]] if len(stable_idx) > 0 else "Non stabilisé"
+            fig, ax = plt.subplots()
+            ax.plot(time0, u[induB, :], label='u_B (tip)', linewidth=2)
+            ax.plot(time0, fA, label='Consigne f_A', linestyle='--')
+            ax.legend()
+            ax.set_title(f"Boucle ouverte ({solicitation}) : Déplacement du tip")
+            ax.set_xlabel("Temps (s)")
+            ax.set_ylabel("Déplacement (m)")
+            animation = generate_animation(ixe, u[::2, :], f"Déformation en boucle ouverte ({solicitation})")
+        elif mode == "Boucle fermée PID":
+            u_ref = Heaviside(time0 - 1)
+            u = np.zeros((ndo1, len(time0)))
+            v = np.zeros((ndo1, len(time0)))
+            a = np.zeros((ndo1, len(time0)))
+            u[:, 0] = np.zeros(ndo1)
+            v[:, 0] = np.zeros(ndo1)
+            a[:, 0] = np.linalg.solve(M, -C @ v[:, 0] - K @ u[:, 0])
+            integ_e = 0
+            prev_e = 0
+            errors = []
+            for step in range(1, len(time0)):
+                uB_meas = u[induB, step-1] + mpert[step-1]
+                e = u_ref[step] - uB_meas
+                integ_e += e * delta
+                de = (e - prev_e) / delta
+                Fpid = Kp * e + Ki * integ_e + Kd * de
+                f_k = np.zeros(ndo1)
+                f_k[induA] = Fpid + fpert[step]
+                u[:, step], v[:, step], a[:, step] = newmark1stepMRHS(M, C, K, f_k, u[:, step-1], v[:, step-1], a[:, step-1], delta, beta, gamma)
+                prev_e = e
+                errors.append(e)
+            u_open = None
+            if compare_open:
+                fA_comp = Heaviside(time0 - 1)
+                f_comp = np.zeros((ndo1, len(time0)))
+                f_comp[induA, :] = fA_comp + fpert
+                u_open, _, _ = Newmark(M, C, K, f_comp, np.zeros(ndo1), np.zeros(ndo1), np.linalg.solve(M, f_comp[:, 0]), delta, beta, gamma)
+            fig, ax = plt.subplots()
+            ax.plot(time0, u[induB, :], label='u_B PID', linewidth=2)
+            if u_open is not None:
+                ax.plot(time0, u_open[induB, :], label='u_B open loop', linestyle='--')
+            ax.plot(time0, u_ref, label='Consigne', linestyle='-.')
+            ax.legend()
+            ax.set_title("Boucle fermée PID : Déplacement u_B")
+            ax.set_xlabel("Temps (s)")
+            ax.set_ylabel("Déplacement (m)")
+            animation = generate_animation(ixe, u[::2, :], "Déformation en boucle fermée")
+        elif mode == "Filtre de Kalman":
+            n_state = 2 * ndo1
+            Q = np.eye(n_state) * q
+            R = r
+            P = np.eye(n_state) * 1e-3
+            x_est = np.zeros(n_state)
+            A = Fconstruct(M, C, K, delta, beta, gamma)[:n_state, :n_state]
+            B_mat = Bconstruct(M, C, K, nA, delta, beta, gamma)[:n_state, :ndo1]
+            H = np.zeros((1, n_state))
+            H[0, induB] = 1
+            u_sim = np.zeros((ndo1, len(time0)))
+            v_sim = np.zeros((ndo1, len(time0)))
+            u_sim[:, 0] = np.zeros(ndo1)
+            v_sim[:, 0] = np.zeros(ndo1)
+            estimates = []
+            P_history = [P.copy()]
+            for step in range(1, len(time0)):
+                f_k = np.zeros(ndo1)
+                u_sim[:, step], v_sim[:, step], _ = newmark1stepMRHS(M, C, K, f_k, u_sim[:, step-1], v_sim[:, step-1], np.zeros(ndo1), delta, beta, gamma)
+                z = None
+                if not without_measure:
+                    z = u_sim[induB, step] + mpert[step]
+                x_pred = A @ x_est
+                P_pred = A @ P @ A.T + Q
+                if not without_measure and z is not None:
+                    K_kal = P_pred @ H.T @ np.linalg.inv(H @ P_pred @ H.T + R)
+                    x_est = x_pred + K_kal @ (z - H @ x_pred)
+                    P = (np.eye(n_state) - K_kal @ H) @ P_pred
+                else:
+                    x_est = x_pred
+                    P = P_pred
+                estimates.append(x_est[induB])
+                P_history.append(P.copy())
+            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+            ax1.plot(time0[1:], estimates, label='Estimation Kalman', linewidth=2)
+            ax1.plot(time0, u_sim[induB, :], label='Vraie u_B', linestyle='--')
+            ax1.legend()
+            ax1.set_title("Estimation de u_B")
+            ax1.set_xlabel("Temps (s)")
+            ax1.set_ylabel("Déplacement (m)")
+            cov_uB = [P[induB, induB] for P in P_history]
+            ax2.plot(time0, cov_uB, label='Covariance u_B', linewidth=2)
+            ax2.legend()
+            ax2.set_title("Évolution de la covariance")
+            ax2.set_xlabel("Temps (s)")
+            ax2.set_ylabel("Variance")
+            animation = "Animation non disponible pour Kalman"
+        else:
+            return "Mode non implémenté", "", f"Temps: {time.time() - start_time:.2f}s"
+
+        buf = BytesIO()
+        fig.savefig(buf, format="png", dpi=100)
+        buf.seek(0)
+        plot_b64 = base64.b64encode(buf.read()).decode('utf-8')
+        plt.close(fig)
+        plot_html = f'<img src="data:image/png;base64,{plot_b64}" style="max-width:100%;">'
+        elapsed = f"Temps de calcul: {time.time() - start_time:.2f}s"
+        if mode == "Boucle ouverte":
+            info_str = f"{elapsed}, Stabilité: {settling_time}"
+        else:
+            info_str = elapsed
+        return plot_html, animation, info_str
+    except Exception as e:
+        return f"Erreur: {str(e)}", "", f"Temps: {time.time() - start_time:.2f}s"
+
+def generate_schema():
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.text(0.1, 0.8, 'i', fontsize=14, ha='center')
+    ax.arrow(0.15, 0.8, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.3, 0.8, 'Moteur', fontsize=14, ha='center', bbox=dict(boxstyle="round,pad=0.3", facecolor="lightblue"))
+    ax.arrow(0.4, 0.8, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.55, 0.8, 'F_m', fontsize=14, ha='center')
+    ax.arrow(0.6, 0.8, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.75, 0.8, 'Transmission', fontsize=14, ha='center', bbox=dict(boxstyle="round,pad=0.3", facecolor="lightgreen"))
+    ax.arrow(0.85, 0.8, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.95, 0.8, 'F_t', fontsize=14, ha='center')
+    ax.arrow(0.15, 0.5, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.3, 0.5, 'C_m', fontsize=14, ha='center')
+    ax.arrow(0.4, 0.5, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.55, 0.5, 'θ', fontsize=14, ha='center')
+    ax.arrow(0.6, 0.5, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.75, 0.5, 'f_A', fontsize=14, ha='center')
+    ax.arrow(0.85, 0.5, 0.1, 0, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.95, 0.5, 'u_A', fontsize=14, ha='center')
+    ax.arrow(0.5, 0.3, 0, -0.1, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.5, 0.2, 'Poutre Flexible', fontsize=14, ha='center', bbox=dict(boxstyle="round,pad=0.3", facecolor="lightcoral"))
+    ax.arrow(0.5, 0.1, 0, -0.05, head_width=0.03, head_length=0.03, fc='k', ec='k')
+    ax.text(0.5, 0.05, 'u_B', fontsize=14, ha='center')
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    ax.axis('off')
+    buf = BytesIO()
+    fig.savefig(buf, format="png", dpi=100)
+    buf.seek(0)
+    img_b64 = base64.b64encode(buf.read()).decode('utf-8')
+    plt.close(fig)
+    return f'<img src="data:image/png;base64,{img_b64}" style="max-width:100%;">'
+
+def compute_ft_gt(rendement, cm, theta_dot, fa_dot, ua_dot):
+    if rendement == 1:
+        ft = cm * theta_dot
+        gt = fa_dot * ua_dot
+        equal = "Oui" if np.isclose(ft, gt) else "Non"
+        return f"F_t = {ft:.3f}, G_t = {gt:.3f}, Égal: {equal}"
+    else:
+        return r"Pour rendement unitaire, F_t = C_m * \dot{\theta}, G_t = f_A * \dot{u_A}"
+
+def quiz_answer(choice):
+    if choice == "Estimer u_B sans mesure directe":
+        return "Correct ! Le jumeau permet d'estimer états non mesurés."
+    else:
+        return "Incorrect. Réessayez."
+
+desc_prep = r"""
+### Travail Préparatoire (Section 4.1 des rapports)
+Étude du système : Schéma bloc en boucle ouverte. Relation F_t et G_t : Sous hypothèse de conservation d'énergie (rendement unitaire), F_t = G_t (d'après conservation C_m \dot{\theta} = f_A \dot{u_A}).  
+Intérêt du jumeau : Estimer u_B sans mesure directe pour contrôle en boucle fermée.  
+"""
+desc_open = """
+### Boucle Ouverte (Section 4.2.1)
+Simulation sans rétroaction. Observez le déplacement u_B avec/sans perturbation. La position de B suit A avec retard (forme sinusoïdale ou échelon).  
+"""
+desc_pid = """
+### Boucle Fermée PID
+Contrôle avec PID pour suivre la consigne. Observez l'erreur de suivi.
+"""
+desc_kalman = """
+### Filtre de Kalman
+Estimation d'état avec filtre Kalman pour filtrer le bruit sur la mesure u_B.
+"""
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Jumeaux Numériques : Simulation de Robot Souple\nDémo interactive basée sur le cours de Renaud Ferrier - Centrale Lyon ENISE.")
+    
+    with gr.Tabs():
+        with gr.Tab("Préparatoire"):
+            gr.Markdown(desc_prep)
+            gr.Markdown("### Schéma Bloc du Système")
+            schema_img = gr.HTML(value=generate_schema())
+            gr.Markdown("### Conservation d'Énergie : F_t = G_t")
+            with gr.Row():
+                rendement_slider = gr.Slider(0.5, 1, 1, label="Rendement (η)", info="Hypothèse rendement unitaire pour conservation")
+                cm_input = gr.Number(1e-3, label="C_m (constante moteur)")
+                theta_dot_input = gr.Number(10, label="\\dot{\\theta} (vitesse angulaire)")
+                fa_dot_input = gr.Number(100, label="f_A (force en A)")
+                ua_dot_input = gr.Number(0.1, label="\\dot{u_A} (vitesse en A)")
+            compute_btn = gr.Button("Calculer F_t et G_t")
+            ft_gt_output = gr.Textbox(label="Résultat")
+            compute_btn.click(compute_ft_gt, inputs=[rendement_slider, cm_input, theta_dot_input, fa_dot_input, ua_dot_input], outputs=ft_gt_output)
+            gr.Markdown("### Intérêt du Jumeau Numérique")
+            quiz_radio = gr.Radio(["Estimer u_B sans mesure directe", "Simuler rapidement", "Réduire coûts"], label="Quel est l'intérêt principal du jumeau ?")
+            quiz_btn = gr.Button("Vérifier")
+            quiz_output = gr.Textbox()
+            quiz_btn.click(quiz_answer, inputs=quiz_radio, outputs=quiz_output)
+            gr.Markdown("### Probabilités Gaussiennes pour Bruits\nDensité : $ p(x) = \\frac{1}{\\sqrt{2\\pi \\sigma^2}} \\exp\\left(-\\frac{(x-\\mu)^2}{2\\sigma^2}\\right) $\nUtilisée pour covariances Q, R dans Kalman.")
+
+        with gr.Tab("Boucle ouverte"):
+            gr.Markdown(desc_open)
+            solicitation_dropdown = gr.Dropdown(["échelon", "sinusoïdale"], value="échelon", label="Type de sollicitation", info="Échelon à t=1s ou sinusoïdale")
+            with gr.Row():
+                nx_slider = gr.Slider(5, 20, 10, 1, label="nx (éléments)", info="Précision poutre")
+                delta_slider = gr.Slider(0.001, 0.05, 0.01, label="δt (pas temps)")
+                q_slider = gr.Slider(0, 0.001, 0.0001, label="q (variance perturbation)")
+            with_pert = gr.Checkbox(True, label="Perturbation ?")
+            compare_open_open = gr.Checkbox(False, visible=False)
+            without_measure_open = gr.Checkbox(False, visible=False)
+            mode_open = gr.Textbox("Boucle ouverte", visible=False)
+            run_open = gr.Button("Simuler")
+            plot_open = gr.HTML()
+            anim_open = gr.HTML()
+            time_open = gr.Textbox(label="Info")
+            run_open.click(run_simulation, inputs=[nx_slider, delta_slider, q_slider, gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Checkbox(value=False, visible=False), with_pert, gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), solicitation_dropdown, compare_open_open, without_measure_open, mode_open], outputs=[plot_open, anim_open, time_open])
+        
+        with gr.Tab("Boucle fermée PID"):
+            gr.Markdown(desc_pid)
+            with gr.Row():
+                nx_pid = gr.Slider(5, 20, 10, 1, label="nx")
+                delta_pid = gr.Slider(0.001, 0.05, 0.01, label="δt")
+                r_pid = gr.Slider(0, 0.001, 0.0001, label="r (bruit mesure)")
+                Kp_slider = gr.Slider(0, 10, 0.5, label="Kp")
+                Ki_slider = gr.Slider(0, 1, 0.1, label="Ki")
+                Kd_slider = gr.Slider(0, 0.1, 0.01, label="Kd")
+            with_noise_pid = gr.Checkbox(True, label="Bruit mesure ?")
+            compare_open_pid = gr.Checkbox(False, label="Comparer avec boucle ouverte")
+            solicitation_pid = gr.Textbox("échelon", visible=False)
+            without_measure_pid = gr.Checkbox(False, visible=False)
+            mode_pid = gr.Textbox("Boucle fermée PID", visible=False)
+            run_pid = gr.Button("Simuler")
+            plot_pid = gr.HTML()
+            anim_pid = gr.HTML()
+            time_pid = gr.Textbox()
+            run_pid.click(run_simulation, inputs=[nx_pid, delta_pid, gr.Number(value=0, visible=False), r_pid, Kp_slider, Ki_slider, Kd_slider, gr.Number(value=0, visible=False), with_noise_pid, gr.Checkbox(value=False, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), solicitation_pid, compare_open_pid, without_measure_pid, mode_pid], outputs=[plot_pid, anim_pid, time_pid])
+        
+        with gr.Tab("Filtre de Kalman"):
+            gr.Markdown(desc_kalman)
+            with gr.Row():
+                nx_kal = gr.Slider(5, 15, 10, 1, label="nx")
+                delta_kal = gr.Slider(0.001, 0.05, 0.01, label="δt")
+                q_kal = gr.Slider(0, 0.001, 0.0001, label="q (bruit processus)")
+                r_kal = gr.Slider(0, 0.001, 0.0001, label="r (bruit mesure)")
+            without_measure_kal = gr.Checkbox(False, label="Sans mesure u_B (jumeau)")
+            solicitation_kal = gr.Textbox("échelon", visible=False)
+            compare_open_kal = gr.Checkbox(False, visible=False)
+            mode_kal = gr.Textbox("Filtre de Kalman", visible=False)
+            run_kal = gr.Button("Simuler")
+            plot_kal = gr.HTML()
+            anim_kal = gr.HTML()
+            time_kal = gr.Textbox()
+            run_kal.click(run_simulation, inputs=[nx_kal, delta_kal, q_kal, r_kal, gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Checkbox(value=False, visible=False), gr.Checkbox(value=False, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), gr.Number(value=0, visible=False), solicitation_kal, compare_open_kal, without_measure_kal, mode_kal], outputs=[plot_kal, anim_kal, time_kal])
+
+demo.launch()

requirements.txt

@@ -1,6 +1,3 @@
 gradio==4.32.0
 numpy==1.24.3
-matplotlib==3.7.2
-scipy==1.10.1
-pillow==9.5.0
-huggingface_hub==0.19.4
+matplotlib==3.7.2

requirements_complex.txt

@@ -0,0 +1,6 @@
+gradio==4.32.0
+numpy==1.24.3
+matplotlib==3.7.2
+scipy==1.10.1
+pillow==9.5.0
+huggingface_hub==0.19.4