modulation-da 0.0.1__py3-none-any.whl

modulation_da/exempleBeltako.py

@@ -0,0 +1,638 @@
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import os
+from time import time
+import scipy.optimize
+
+# Configuration TensorFlow
+tf.random.set_seed(1234)
+np.random.seed(1234)
+
+class QuantumPINNSolver:
+    def __init__(self):
+        # Paramètres physiques
+        self.e_charge = 1.602176634e-19
+        self.hbar = 6.582119514e-16  # eV·s
+        self.KB = 8.6173303e-5  # eV/K
+        self.pi = np.pi
+
+        # Paramètres du système
+        self.n = 3  # nombre de modes
+        self.Ne = 20  # discrétisation en énergie
+        self.N = 15000  #15000  # points de collocation
+        self.N_0 = 2000  # points de condition initiale
+        self.N_pred = 5000  # points de prédiction
+        self.N_train_adam = 90000  # époques d'entraînement Adam
+        self.N_train_lbfgs = 3000  # époques d'entraînement L-BFGS
+
+        # Paramètres énergétiques (eV)
+        self.E_min = -2.5
+        self.E_max = 2.5
+        self.dE = (self.E_max - self.E_min) / self.Ne
+        self.Ef = 0.0
+        self.Temp = 10
+        self.KBT = self.KB * self.Temp
+
+        # Paramètres du système quantique (eV)
+        self.GammaL = 0.05
+        self.GammaR = 0.05
+        self.molE = 0.7
+        self.Eg = 2 * self.molE
+        self.tm = 0.1
+
+        # Paramètres temporels (s)
+        self.Power = 1.0e-15
+        self.t_min = 0 * self.Power
+        self.t_max = 100 * self.Power
+
+        # Paramètres de perturbation gaussienne
+        self.cent = 15 * self.Power  # s
+        self.he1 = 0.500  # eV
+        self.he2 = 0.00   # eV
+        self.W0 = 5.0 * self.Power  # s
+        self.W1 = self.Eg / self.hbar  # rad/s
+        self.tau = 6 * self.Power  # s
+
+        # NORMALISATION PHYSIQUE
+        self._setup_normalization()
+        self._setup_system()
+
+    def _setup_normalization(self):
+        """Configure les échelles de normalisation basées sur la physique"""
+        # Échelles caractéristiques du système
+        self.E_scale = abs(self.molE)  # Échelle d'énergie caractéristique (eV)
+        self.t_scale = self.hbar / self.E_scale  # Échelle de temps caractéristique (s)
+        self.psi_scale = 1.0  # Les fonctions d'onde sont sans dimension
+        # FACTEURS D'ÉCHELLE POUR LES UNITÉS PHYSIQUES
+        # Le courant normalisé doit être multiplié par ce facteur pour obtenir des Ampères
+        self.current_scale = self.e_charge / self.t_scale  # A
+        print(f"Échelles de normalisation:")
+        print(f"  Énergie: {self.E_scale:.3f} eV")
+        print(f"  Temps: {self.t_scale:.2e} s")
+        print(f"  Temps physique max: {self.t_max:.2e} s")
+        print(f"  Temps normalisé max: {self.t_max/self.t_scale:.3f}")
+        print(f"  Facteur de conversion du courant: {self.current_scale:.6e} A")
+
+        # Vérification de cohérence dimensionnelle
+        hbar_over_t_scale = self.hbar / self.t_scale  # eV
+        print(f"  Vérification: ℏ/t_scale = {hbar_over_t_scale:.3f} eV = E_scale = {self.E_scale:.3f} eV ✓")
+
+    def _setup_system(self):
+        """Initialise les matrices du système avec normalisation"""
+        # Hamiltonien non perturbé (normalisé)
+        self.H_0 = np.array([
+            [-self.molE/self.E_scale, 0.0, 0.0],
+            [0.0, self.molE/self.E_scale, self.tm/self.E_scale],
+            [0.0, self.tm/self.E_scale, self.molE/self.E_scale]
+        ], dtype=complex)
+
+        # Auto-énergies (normalisées)
+        SEL1 = np.zeros((self.n, self.n), dtype=complex)
+        SEL1[0, 0] = -1j * self.GammaL/self.E_scale
+        SEL1[1, 1] = -1j * self.GammaL/self.E_scale
+
+        SEL2 = np.zeros((self.n, self.n), dtype=complex)
+        SEL2[2, 2] = -1j * self.GammaR/self.E_scale
+
+        self.SELF = SEL1 + SEL2
+
+        # Normalisation des autres paramètres
+        self.E_min_norm = self.E_min / self.E_scale
+        self.E_max_norm = self.E_max / self.E_scale
+        self.dE_norm = self.dE / self.E_scale
+        self.Ef_norm = self.Ef / self.E_scale
+        self.KBT_norm = self.KBT / self.E_scale
+
+        self.t_min_norm = self.t_min / self.t_scale
+        self.t_max_norm = self.t_max / self.t_scale
+
+        # Paramètres de perturbation normalisés
+        self.cent_norm = self.cent / self.t_scale
+        self.he1_norm = self.he1 / self.E_scale
+        self.he2_norm = self.he2 / self.E_scale
+        self.W0_norm = self.W0 / self.t_scale
+        self.W1_norm = self.W1 * self.t_scale  # W1 était en rad/s, maintenant sans dimension
+        self.tau_norm = self.tau / self.t_scale
+
+        # Résolution des états stationnaires avec énergies normalisées
+        self._solve_stationary_states()
+
+    def fermi_dirac(self, E_norm, mu_norm, KBT_norm):
+        """Fonction de Fermi-Dirac avec paramètres normalisés"""
+        return 1.0 / (1.0 + np.exp((E_norm - mu_norm) / KBT_norm))
+
+    def _solve_stationary_states(self):
+        """Résout les états stationnaires pour chaque énergie normalisée"""
+        self.stock_psi = np.zeros((self.Ne, self.n, self.n), dtype=complex)
+        vecs = [np.eye(self.n)[:, j:j+1] * np.sqrt(self.GammaL/self.E_scale) for j in range(self.n)]
+
+        for i in range(self.Ne):
+            E_norm = self.E_min_norm + i * self.dE_norm
+            a = E_norm * np.eye(self.n, dtype=complex)
+            GR = np.linalg.inv(a - self.H_0 - self.SELF)
+
+            for j in range(self.n):
+                vec = vecs[j]
+                psi_st = GR @ vec
+                self.stock_psi[i, j, :] = psi_st[:, 0]
+
+    def perturb_gauss(self, t_norm):
+        """Calcule la perturbation gaussienne avec temps normalisé"""
+        How = np.zeros((self.n, self.n), dtype=complex)
+        valeur = (-self.he1_norm * np.cos(self.W1_norm * (t_norm - self.cent_norm)) *
+                 np.exp(-((t_norm - self.cent_norm)**2) / (2 * self.W0_norm**2)) -
+                 self.he2_norm * np.cos(self.W1_norm * (t_norm - self.cent_norm - self.tau_norm)) *
+                 np.exp(-((t_norm - self.cent_norm - self.tau_norm)**2) / (2 * self.W0_norm**2)))
+        How[0, 1] = valeur
+        How[1, 0] = valeur
+        return How
+
+    def create_model(self, num_hidden_layer=4, num_neurons_per_layer=64):
+        model = tf.keras.Sequential()
+        model.add(tf.keras.layers.InputLayer(input_shape=(1,)))
+        for _ in range(num_hidden_layer):
+            model.add(tf.keras.layers.Dense(num_neurons_per_layer, activation='tanh',
+                                          kernel_initializer='glorot_normal'))
+        model.add(tf.keras.layers.Dense(2 * self.n))
+        return model
+
+    def physics_loss(self, model, t_colloc_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i):
+        """Calcule la perte physique basée sur l'EDP avec unités cohérentes"""
+        with tf.GradientTape(persistent=True) as tape:
+            tape.watch(t_colloc_norm)
+            psi_pred = model(t_colloc_norm)
+            u = psi_pred[:, :self.n]
+            v = psi_pred[:, self.n:]
+
+        u_t = tape.batch_jacobian(u, t_colloc_norm)[:, :, 0]
+        v_t = tape.batch_jacobian(v, t_colloc_norm)[:, :, 0]
+        del tape
+
+        # Terme source S(t)
+        E_complex = tf.cast(E_norm, tf.complex64)
+        t_complex = tf.cast(tf.squeeze(t_colloc_norm), tf.complex64)
+        phase = tf.exp(-1j * E_complex * t_complex)
+        phase = tf.expand_dims(phase, axis=-1)
+
+        psi_st_broadcast = tf.transpose(psi_st_tensor)
+        expo_term = phase * psi_st_broadcast
+        expo_term = tf.expand_dims(expo_term, axis=-1)
+
+        S_complex = tf.matmul(HP_tensor, expo_term)
+        S_complex = tf.squeeze(S_complex, axis=-1)
+        S_r = tf.math.real(S_complex)
+        S_i = tf.math.imag(S_complex)
+
+        # Équations résiduelles
+        u_exp = tf.expand_dims(u, axis=-1)
+        v_exp = tf.expand_dims(v, axis=-1)
+
+        r_u = u_t - tf.squeeze(tf.matmul(H_t_r, v_exp), axis=-1) - tf.squeeze(tf.matmul(H_t_i, u_exp), axis=-1) - S_i
+        r_v = -v_t - tf.squeeze(tf.matmul(H_t_r, u_exp), axis=-1) + tf.squeeze(tf.matmul(H_t_i, v_exp), axis=-1) - S_r
+
+        pde_loss = tf.reduce_mean(tf.square(r_u)) + tf.reduce_mean(tf.square(r_v))
+        return pde_loss
+
+    def initial_conditions_loss(self, model, t_0_norm):
+        """Perte pour les conditions initiales (nulles)"""
+        psi_pred_0 = model(t_0_norm)
+        u_0 = psi_pred_0[:, :self.n]
+        v_0 = psi_pred_0[:, self.n:]
+        ic_loss = tf.reduce_mean(tf.square(u_0)) + tf.reduce_mean(tf.square(v_0))
+        return ic_loss
+
+    def total_loss(self, model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i):
+        """Perte totale combinant physique et conditions initiales"""
+        pde_loss = self.physics_loss(model, t_colloc_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i)
+        ic_loss = self.initial_conditions_loss(model, t_0_norm)
+
+        lambda_pde = 1.0
+        lambda_ic = 1.0
+
+        return lambda_pde * pde_loss + lambda_ic * ic_loss, pde_loss, ic_loss
+
+    def get_weights(self, model):
+        """Extrait les poids du modèle sous forme de vecteur 1D"""
+        weights = []
+        for layer in model.layers:
+            if hasattr(layer, 'get_weights') and layer.get_weights():
+                for w in layer.get_weights():
+                    weights.append(w.flatten())
+        return np.concatenate(weights) if weights else np.array([])
+
+    def set_weights(self, model, weights_1d):
+        """Restaure les poids du modèle à partir d'un vecteur 1D"""
+        idx = 0
+        for layer in model.layers:
+            if hasattr(layer, 'get_weights') and layer.get_weights():
+                layer_weights = []
+                for w in layer.get_weights():
+                    size = w.size
+                    new_w = weights_1d[idx:idx+size].reshape(w.shape)
+                    layer_weights.append(new_w)
+                    idx += size
+                layer.set_weights(layer_weights)
+
+    def lbfgs_loss_func(self, weights_1d, model, t_colloc_norm, t_0_norm, E_norm,
+                       psi_st_tensor, HP_tensor, H_t_r, H_t_i):
+        """Fonction de perte pour L-BFGS"""
+        # Restaurer les poids
+        self.set_weights(model, weights_1d)
+
+        # Calculer la perte
+        with tf.GradientTape() as tape:
+            loss, pde_loss, ic_loss = self.total_loss(
+                model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+            )
+
+        # Calculer les gradients
+        gradients = tape.gradient(loss, model.trainable_variables)
+
+        # Convertir les gradients en vecteur 1D
+        grad_1d = []
+        for grad in gradients:
+            if grad is not None:
+                grad_1d.append(grad.numpy().flatten())
+        grad_1d = np.concatenate(grad_1d) if grad_1d else np.array([])
+
+        return float(loss.numpy()), grad_1d.astype(np.float64)
+
+    def train_model_hybrid(self, model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor,
+                          HP_tensor, H_t_r, H_t_i):
+        """Entraîne le modèle avec Adam puis L-BFGS"""
+
+        # Phase 1: Entraînement avec Adam
+        print("Phase 1: Entraînement avec Adam...")
+
+        # Optimiseur Adam avec taux d'apprentissage adaptatif
+        initial_lr = 1e-3
+        lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
+            initial_learning_rate=initial_lr,
+            decay_steps=30000,
+            decay_rate=0.9,
+            staircase=True
+        )
+        optimizer_adam = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
+
+        @tf.function
+        def adam_train_step():
+            with tf.GradientTape() as tape:
+                loss, pde_loss, ic_loss = self.total_loss(
+                    model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+                )
+            gradients = tape.gradient(loss, model.trainable_variables)
+            optimizer_adam.apply_gradients(zip(gradients, model.trainable_variables))
+            return loss, pde_loss, ic_loss
+
+        adam_history = {'total_loss': [], 'pde_loss': [], 'ic_loss': []}
+        t_start_adam = time()
+
+        for epoch in range(self.N_train_adam):
+            loss, pde_loss, ic_loss = adam_train_step()
+
+            if epoch % 1000 == 0:
+                print(f"Adam Epoch {epoch:5d}: Total = {loss:.6e}, PDE = {pde_loss:.6e}, IC = {ic_loss:.6e}")
+
+            adam_history['total_loss'].append(float(loss))
+            adam_history['pde_loss'].append(float(pde_loss))
+            adam_history['ic_loss'].append(float(ic_loss))
+
+            # Critère d'arrêt précoce pour Adam
+            if epoch > 1000 and loss < 1e-4:
+                print(f"Arrêt précoce d'Adam à l'époque {epoch}")
+                break
+
+        print(f"Temps d'entraînement Adam: {time() - t_start_adam:.2f} secondes")
+        print(f"Perte finale Adam: {loss:.6e}")
+
+        # Phase 2: Raffinement avec L-BFGS
+        print("\nPhase 2: Raffinement avec L-BFGS...")
+
+        t_start_lbfgs = time()
+
+        # Poids initiaux pour L-BFGS
+        initial_weights = self.get_weights(model)
+
+        # Configuration L-BFGS
+        lbfgs_options = {
+            'maxiter': self.N_train_lbfgs,
+            'maxfun': self.N_train_lbfgs * 2,
+            'ftol': 1e-12,
+            'gtol': 1e-12,
+            'eps': 1e-8,
+            'disp': True
+        }
+
+        # Variables pour suivre les itérations L-BFGS
+        self.lbfgs_iter = 0
+        self.lbfgs_losses = []
+
+        def callback_func(xk):
+            self.lbfgs_iter += 1
+            if self.lbfgs_iter % 100 == 0:
+                # Calculer la perte actuelle pour l'affichage
+                self.set_weights(model, xk)
+                loss, pde_loss, ic_loss = self.total_loss(
+                    model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+                )
+                print(f"L-BFGS Iter {self.lbfgs_iter:4d}: Total = {loss:.6e}, PDE = {pde_loss:.6e}, IC = {ic_loss:.6e}")
+                self.lbfgs_losses.append(float(loss))
+
+        # Optimisation L-BFGS
+        try:
+            result = scipy.optimize.minimize(
+                fun=lambda w: self.lbfgs_loss_func(w, model, t_colloc_norm, t_0_norm,
+                                                  E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i),
+                x0=initial_weights.astype(np.float64),
+                method='L-BFGS-B',
+                jac=True,
+                callback=callback_func,
+                options=lbfgs_options
+            )
+
+            # Restaurer les poids optimaux
+            self.set_weights(model, result.x)
+
+            print(f"L-BFGS terminé: {result.message}")
+            print(f"Nombre d'itérations: {result.nit}")
+            print(f"Perte finale: {result.fun:.6e}")
+
+        except Exception as e:
+            print(f"Erreur L-BFGS: {e}")
+            print("Utilisation des poids d'Adam comme solution finale")
+
+        print(f"Temps d'entraînement L-BFGS: {time() - t_start_lbfgs:.2f} secondes")
+
+        # Évaluation finale
+        final_loss, final_pde_loss, final_ic_loss = self.total_loss(
+            model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+        )
+        print(f"Perte finale combinée: Total = {final_loss:.6e}, PDE = {final_pde_loss:.6e}, IC = {final_ic_loss:.6e}")
+
+        # Historique combiné
+        combined_history = {
+            'adam_history': adam_history,
+            'lbfgs_losses': self.lbfgs_losses,
+            'final_loss': float(final_loss),
+            'final_pde_loss': float(final_pde_loss),
+            'final_ic_loss': float(final_ic_loss)
+        }
+
+        return combined_history
+
+    def solve_for_energy_mode(self, i_energy, j_mode):
+        """Résout pour un mode et une énergie spécifiques"""
+        E_norm = self.E_min_norm + i_energy * self.dE_norm
+
+        # État stationnaire
+        psi_st = self.stock_psi[i_energy, j_mode, :].reshape((self.n, 1))
+        psi_st_tensor = tf.convert_to_tensor(psi_st, dtype=tf.complex64)
+
+        # Grille temporelle pour collocation (normalisée)
+        #t_colloc_norm = tf.reshape(tf.linspace(self.t_min_norm, self.t_max_norm, self.N), (-1, 1))
+        t_colloc_norm = tf.random.uniform((self.N, 1), minval=self.t_min_norm, maxval=self.t_max_norm)
+        t_0_norm = tf.zeros((self.N_0, 1), dtype=tf.float32) + self.t_min_norm
+
+        # Hamiltoniens perturbés (normalisés)
+        HP_list = []
+        for k in range(self.N):
+            t_k_norm = float(t_colloc_norm[k, 0])
+            HP_k = self.perturb_gauss(t_k_norm)
+            HP_list.append(HP_k)
+
+        HP_tensor = tf.convert_to_tensor(np.stack(HP_list), dtype=tf.complex64)
+
+        # Hamiltonien total (normalisé)
+        H_0_tensor = tf.convert_to_tensor(self.H_0, dtype=tf.complex64)
+        SELF_tensor = tf.convert_to_tensor(self.SELF, dtype=tf.complex64)
+
+        H_0_expanded = tf.repeat(tf.expand_dims(H_0_tensor, axis=0), self.N, axis=0)
+        SELF_expanded = tf.repeat(tf.expand_dims(SELF_tensor, axis=0), self.N, axis=0)
+
+        H_t = HP_tensor + H_0_expanded + SELF_expanded
+        H_t_r = tf.math.real(H_t)
+        H_t_i = tf.math.imag(H_t)
+
+        # Création et entraînement du modèle
+        model = self.create_model()
+        history = self.train_model_hybrid(
+            model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+        )
+
+        return model, history, E_norm, psi_st_tensor
+
+    def predict_and_compute_current(self, model, E_norm, psi_st_tensor):
+        """Fait des prédictions et calcule le courant"""
+        # Grille temporelle pour prédiction (normalisée)
+        t_pred_norm_vals = np.linspace(self.t_min_norm, self.t_max_norm, self.N_pred)
+        t_pred_norm = tf.convert_to_tensor(t_pred_norm_vals.reshape(-1, 1), dtype=tf.float32)
+
+        # Hamiltoniens pour prédiction (normalisés)
+        HP_pred_list = []
+        for s in range(self.N_pred):
+            t_s_norm = t_pred_norm_vals[s]
+            HP_s = self.perturb_gauss(t_s_norm)
+            HP_pred_list.append(HP_s)
+
+        HP_pred = tf.convert_to_tensor(np.stack(HP_pred_list), dtype=tf.complex64)
+
+        # Prédiction du réseau
+        psi_pred = model(t_pred_norm)  # [N_pred, 2n]
+        u_pred = psi_pred[:, :self.n]
+        v_pred = psi_pred[:, self.n:]
+        psi_p = tf.complex(u_pred, v_pred)  # [N_pred, n]
+
+        # Ajout de l'état stationnaire avec phase (normalisée)
+        arg = -E_norm * t_pred_norm_vals  # Argument sans dimension
+        phase = tf.exp(1j * tf.cast(arg, tf.complex64))
+        phase = tf.expand_dims(phase, axis=-1)  # [N_pred, 1]
+
+        psi_st_broadcast = tf.transpose(psi_st_tensor)  # [1, n]
+        psi_total = psi_p + phase * psi_st_broadcast  # [N_pred, n]
+
+        return psi_total, t_pred_norm_vals, HP_pred
+
+    def run_full_simulation(self):
+        """Lance la simulation complète"""
+        os.makedirs("TEST1", exist_ok=True)
+
+        J_current = tf.zeros((self.N_pred,), dtype=tf.complex64)
+        all_histories = []
+
+        for i in range(self.Ne):
+            print(f"\n=== Énergie {i+1}/{self.Ne} ===")
+
+            courant_mode = tf.zeros((self.N_pred,), dtype=tf.complex64)
+
+            for j in range(self.n):
+                print(f"\nMode {j+1}/{self.n}")
+
+                model, history, E_norm, psi_st_tensor = self.solve_for_energy_mode(i, j)
+                all_histories.append(history)
+
+                psi_total, t_pred_norm_vals, HP_pred = self.predict_and_compute_current(model, E_norm, psi_st_tensor)
+
+                # Calcul du courant pour ce mode
+                fermi_factor = self.fermi_dirac(E_norm, self.Ef_norm, self.KBT_norm)
+                fermi_tensor = tf.convert_to_tensor(fermi_factor, dtype=tf.complex64)
+
+                # Hamiltonien total pour le courant (normalisé)
+                H_0_tensor = tf.convert_to_tensor(self.H_0, dtype=tf.complex64)
+                SELF_tensor = tf.convert_to_tensor(self.SELF, dtype=tf.complex64)
+
+                H_0_pred = tf.repeat(tf.expand_dims(H_0_tensor, axis=0), self.N_pred, axis=0)
+                SELF_pred = tf.repeat(tf.expand_dims(SELF_tensor, axis=0), self.N_pred, axis=0)
+
+                HT_pred = HP_pred + H_0_pred + SELF_pred
+
+                # Courant: J ∝ ψ₁* H₁₂ ψ₂
+                psi1_conj = tf.math.conj(psi_total[:, 1])
+                H12 = HT_pred[:, 1, 2]
+                psi2 = psi_total[:, 2]
+
+                courant_mode += fermi_tensor * psi1_conj * H12 * psi2
+
+            J_current += self.dE_norm * (1.0 / (2.0 * self.pi)) * courant_mode
+
+        J_current_norm = J_current
+
+        # Courant final
+        CJJ = -2.0 * tf.math.imag(J_current_norm)
+
+        # Sauvegarde
+        J_current_np = J_current_norm.numpy()
+        CJJ_np = CJJ.numpy()
+        # Conversion en unités physiques
+        CJJ_physical_np = CJJ_np * self.current_scale  # Courant en Ampères
+        t_physical_vals = t_pred_norm_vals * self.t_scale  # Temps en secondes
+
+        #np.savetxt("TEST1/COURANT", J_current_np)
+        #np.savetxt("TEST1/CJJ", CJJ_np)
+        # Sauvegarde des données normalisées
+        np.savetxt("TEST1/COURANT_normalized", J_current_np)
+        np.savetxt("TEST1/CJJ_normalized", CJJ_np)
+        np.savetxt("TEST1/time_normalized", t_pred_norm_vals)
+
+        # Sauvegarde des données physiques
+        np.savetxt("TEST1/CJJ_physical", CJJ_physical_np)
+        np.savetxt("TEST1/time_physical", t_physical_vals)
+
+        # Sauvegarde combinée pour facilité d'usage
+        np.savetxt("TEST1/current_data_normalized.dat", 
+           np.column_stack((t_pred_norm_vals, CJJ_np)), 
+           header="Time_normalized Current_normalized", fmt='%.10e')
+        np.savetxt("TEST1/current_data_physical.dat", 
+           np.column_stack((t_physical_vals, CJJ_physical_np)), 
+           header="Time_seconds Current_amperes", fmt='%.10e')
+
+        # Visualisation améliorée
+        fig, axes = plt.subplots(2, 2, figsize=(15, 10))
+
+        # Graphique du courant
+        # Graphique du courant normalisé
+        axes[0, 0].plot(t_pred_norm_vals, CJJ_np, label='Courant normalisé', color='navy', linewidth=2)
+        axes[0, 0].set_xlabel("Temps normalisé (sans dimension)", fontsize=14)
+        axes[0, 0].set_ylabel("Courant normalisé (sans dimension)", fontsize=14)
+        axes[0, 0].set_title("Courant normalisé", fontsize=14)
+        axes[0, 0].grid(True, alpha=0.3)
+        
+        #axes[0, 0].plot(t_pred_norm_vals, CJJ_np, label='Courant CJJ(t)', color='navy', linewidth=2)
+        #axes[0, 0].set_xlabel("Time (unitless)", fontsize=14)
+        #axes[0, 0].set_ylabel("Current (unitless)", fontsize=14)
+        #axes[0, 0].set_title("Current variation over time", fontsize=14)
+        #axes[0, 0].grid(True, alpha=0.3)
+
+        # Composantes du courant complexe
+        axes[0, 1].plot(t_pred_norm_vals, np.real(J_current_np), label='Re(J)', color='red', linewidth=1)
+        axes[0, 1].plot(t_pred_norm_vals, np.imag(J_current_np), label='Im(J)', color='green', linewidth=1)
+        axes[0, 1].set_xlabel("Temps (unitless)", fontsize=14)
+        axes[0, 1].set_ylabel("J_current", fontsize=14)
+        axes[0, 1].set_title("Composantes du courant", fontsize=14)
+        axes[0, 1].legend()
+        axes[0, 1].grid(True, alpha=0.3)
+        # Convergence Adam (premier mode/énergie comme exemple)
+        if all_histories:
+            first_history = all_histories[0]
+            if 'adam_history' in first_history:
+                adam_hist = first_history['adam_history']
+                axes[1, 0].semilogy(adam_hist['total_loss'], label='Total Loss', color='blue', linewidth=1)
+                axes[1, 0].semilogy(adam_hist['pde_loss'], label='PDE Loss', color='orange', linewidth=1)
+                axes[1, 0].semilogy(adam_hist['ic_loss'], label='IC Loss', color='purple', linewidth=1)
+                axes[1, 0].set_xlabel("Epochs Adam", fontsize=12)
+                axes[1, 0].set_ylabel("Loss", fontsize=12)
+                axes[1, 0].set_title("Convergence Adam", fontsize=12)
+                axes[1, 0].legend()
+                axes[1, 0].grid(True, alpha=0.3)
+                              
+        # Graphique du courant physique
+        axes[1, 1].plot(t_physical_vals * 1e15, CJJ_physical_np, 
+               label='Courant physique', color='darkred', linewidth=2)
+        axes[1, 1].set_xlabel("Temps (fs)", fontsize=12)
+        axes[1, 1].set_ylabel("Courant (A)", fontsize=12)
+        axes[1, 1].set_title("Courant physique", fontsize=12)
+        axes[1, 1].grid(True, alpha=0.3)
+        
+        
+        # Perturbation gaussienne
+        # Figure séparée pour la perturbation gaussienne
+        plt.figure(figsize=(10, 6))
+        t_pert = np.linspace(self.t_min_norm, self.t_max_norm, 1000)
+        pert_values = []
+        for t in t_pert:
+            H_pert = self.perturb_gauss(t)
+            pert_values.append(np.real(H_pert[0, 1]))  # Élément (0,1) réel
+
+        plt.plot(t_pert, pert_values, label='Perturbation H₀₁(t)', color='darkgreen', linewidth=2)
+        plt.xlabel("Temps normalisé (sans dimension)", fontsize=14)
+        plt.ylabel("Amplitude normalisée", fontsize=14)
+        plt.title("Perturbation gaussienne", fontsize=16)
+        plt.grid(True, alpha=0.3)
+        plt.tight_layout()
+        plt.savefig("TEST1/perturbation_gaussian.png", dpi=300, bbox_inches='tight')
+        plt.show()
+        
+    
+
+        plt.tight_layout()
+        plt.savefig("TEST1/quantum_simulation_results.png", dpi=300, bbox_inches='tight')
+        plt.show()
+
+        # Statistiques de convergence
+        print("\n=== RÉSULTATS DE LA SIMULATION ===")
+        print(f"Courant normalisé maximal: {np.max(np.abs(CJJ_np)):.6e}")
+        print(f"Courant physique maximal: {np.max(np.abs(CJJ_physical_np)):.6e} A")
+        print(f"Courant physique maximal: {np.max(np.abs(CJJ_physical_np)):.6e} A")
+        print(f"Courant normalisé final: {CJJ_np[-1]:.6e}")
+        print(f"Courant physique final: {CJJ_physical_np[-1]:.6e} A")
+        print(f"Facteur de conversion: {self.current_scale:.6e} A")
+        # Résumé des pertes finales
+        final_losses = [hist.get('final_loss', 0) for hist in all_histories]
+        if final_losses:
+            print(f"Perte moyenne finale: {np.mean(final_losses):.6e}")
+            print(f"Perte maximale finale: {np.max(final_losses):.6e}")
+
+        return {
+    'current_normalized': CJJ_np,
+    'current_physical': CJJ_physical_np,
+    'time_normalized': t_pred_norm_vals,
+    'time_physical': t_physical_vals,
+    'complex_current': J_current_np,
+    'current_scale': self.current_scale,
+    'histories': all_histories
+}
+
+# Point d'entrée principal
+if __name__ == "__main__":
+    print("=== SIMULATEUR QUANTUM PINN ===")
+    print("Initialisation du solveur...")
+
+    solver = QuantumPINNSolver()
+
+    print("\nDémarrage de la simulation complète...")
+    results = solver.run_full_simulation()
+
+    print("\n=== SIMULATION TERMINÉE ===")
+    print("Résultats sauvegardés dans le dossier TEST1/")
+    print("Graphiques générés: quantum_simulation_results.png")
+