modulation-da 0.0.1__py3-none-any.whl

modulation_da/quantum_solver.py

@@ -0,0 +1,245 @@
+# quantum_solver.py
+import tensorflow as tf
+import numpy as np
+import os
+from datetime import datetime
+
+# Import correct de tous les modules
+try:
+    from quantum_config import QuantumConfig
+    from quantum_system import QuantumSystem
+    from perturbations import PerturbationManager
+    from pinn_model import PINNModel
+    from current_calculator import CurrentCalculator
+    from results_manager import ResultsManager
+    from visualization import ResultsVisualizer
+except ImportError as e:
+    print(f"Import error: {e}")
+    print("Make sure all module files are in the same directory")
+    raise
+
+class QuantumPINNSolver:
+    """Solveur principal complet qui orchestre toute la simulation"""
+    
+    def __init__(self, perturbation_type='gaussian'):
+        self.perturbation_type = perturbation_type
+        
+        # Initialisation de tous les modules
+        self.config = QuantumConfig()
+        self.system = QuantumSystem(self.config)
+        self.perturbations = PerturbationManager(self.config)
+        self.pinn = PINNModel(self.config)
+        self.current_calc = CurrentCalculator(self.config, self.system)
+        self.results_mgr = ResultsManager(self.config)
+        self.visualizer = ResultsVisualizer(self.results_mgr)
+        
+        # Résultats
+        self.results = None
+        
+    def prepare_training_data(self, E_norm, psi_st_tensor):
+        """Prépare les données d'entraînement pour une énergie/mode donné"""
+        t_colloc_norm = tf.random.uniform((self.pinn.N, 1), 
+                                        minval=self.config.t_min_norm,
+                                        maxval=self.config.t_max_norm)
+        t_0_norm = tf.zeros((self.pinn.N_0, 1), dtype=tf.float32) + self.config.t_min_norm
+
+        # Hamiltoniens perturbés (normalisés)
+        HP_list = []
+        H_r_list = []
+        H_i_list = []
+        
+        for k in range(self.pinn.N):
+            t_k_norm = float(t_colloc_norm[k, 0])
+            HP_k = self.perturbations.get_perturbation(t_k_norm, self.perturbation_type)
+            HP_list.append(HP_k)
+            
+            # Hamiltonien total (normalisé)
+            H_total = HP_k + self.system.H_0 + self.system.SELF
+            H_r_list.append(np.real(H_total))
+            H_i_list.append(np.imag(H_total))
+
+        HP_tensor = tf.convert_to_tensor(np.stack(HP_list), dtype=tf.complex64)
+        H_t_r = tf.convert_to_tensor(np.stack(H_r_list), dtype=tf.float32)
+        H_t_i = tf.convert_to_tensor(np.stack(H_i_list), dtype=tf.float32)
+
+        return t_colloc_norm, t_0_norm, HP_tensor, H_t_r, H_t_i
+
+    def solve_energy_mode(self, i_energy, j_mode):
+        """Résout pour une énergie et un mode spécifiques"""
+        print(f"    Training for energy {i_energy+1}, mode {j_mode+1}...")
+        
+        E_norm = self.config.E_min_norm + i_energy * self.config.dE_norm
+        psi_st = self.system.stock_psi[i_energy, j_mode, :].reshape((self.config.n, 1))
+        psi_st_tensor = tf.convert_to_tensor(psi_st, dtype=tf.complex64)
+        
+        # Préparation données
+        t_colloc, t_0, HP_tensor, H_t_r, H_t_i = self.prepare_training_data(E_norm, psi_st_tensor)
+        
+        # Création et entraînement du modèle
+        model = self.pinn.create_model()
+        
+        # TRAINING
+        history = self.pinn.train_hybrid(model, t_colloc, t_0, 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.config.t_min_norm, self.config.t_max_norm, self.pinn.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.pinn.N_pred):
+            t_s_norm = t_pred_norm_vals[s]
+            HP_s = self.perturbations.get_perturbation(t_s_norm, self.perturbation_type)
+            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.config.n]
+        v_pred = psi_pred[:, self.config.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 avec training et calcul de courant"""
+        print(f"Starting FULL simulation with {self.perturbation_type} perturbation...")
+        
+        J_current = tf.zeros((self.pinn.N_pred,), dtype=tf.complex64)
+        all_histories = []
+
+        for i in range(self.config.Ne):
+            print(f"\n=== Energy {i+1}/{self.config.Ne} ===")
+
+            courant_mode = tf.zeros((self.pinn.N_pred,), dtype=tf.complex64)
+
+            for j in range(self.config.n):
+                print(f"  Mode {j+1}/{self.config.n}")
+
+                model, history, E_norm, psi_st_tensor = self.solve_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.system.fermi_dirac(E_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.system.H_0, dtype=tf.complex64)
+                SELF_tensor = tf.convert_to_tensor(self.system.SELF, dtype=tf.complex64)
+
+                H_0_pred = tf.repeat(tf.expand_dims(H_0_tensor, axis=0), self.pinn.N_pred, axis=0)
+                SELF_pred = tf.repeat(tf.expand_dims(SELF_tensor, axis=0), self.pinn.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.config.dE_norm * (1.0 / (2.0 * self.config.pi)) * courant_mode
+
+        J_current_norm = J_current
+
+        # Courant final
+        CJJ = -2.0 * tf.math.imag(J_current_norm)
+
+        # Conversion en unités physiques
+        CJJ_np = CJJ.numpy()
+        CJJ_physical_np = CJJ_np * self.config.current_scale
+        t_physical_vals = t_pred_norm_vals * self.config.t_scale
+
+        # Génération profil de pulse
+        pulse_profile = self.perturbations.generate_pulse_profile(t_pred_norm_vals, self.perturbation_type)
+
+        self.results = {
+            'current_normalized': CJJ_np,
+            'current_physical': CJJ_physical_np,
+            'time_normalized': t_pred_norm_vals,
+            'time_physical': t_physical_vals,
+            'pulse_profile': pulse_profile,
+            'histories': all_histories
+        }
+        
+        return self.results
+
+    def save_results(self):
+        """Sauvegarde tous les résultats"""
+        if self.results is None:
+            raise ValueError("No results to save. Run simulation first.")
+            
+        self.results_mgr.save_simulation_parameters(self.perturbation_type)
+        self.results_mgr.save_current_data(
+            self.results['time_normalized'], 
+            self.results['time_physical'],
+            self.results['current_normalized'],
+            self.results['current_physical']
+        )
+        self.results_mgr.save_pulse_data(
+            self.results['time_normalized'],
+            self.results['pulse_profile'],
+            self.perturbation_type
+        )
+        
+        print("✓ All results saved successfully")
+
+    def generate_plots(self):
+        """Génère tous les graphiques"""
+        if self.results is None:
+            raise ValueError("No results to plot. Run simulation first.")
+            
+        self.visualizer.plot_current_vs_time(
+            self.results['time_normalized'],
+            self.results['current_normalized'],
+            self.results['time_physical'],
+            self.results['current_physical'],
+            self.perturbation_type
+        )
+        
+        self.visualizer.plot_pulse_profile(
+            self.results['time_normalized'],
+            self.results['pulse_profile'],
+            self.perturbation_type
+        )
+        
+        print("✓ All plots generated successfully")
+
+    def get_simulation_summary(self):
+        """Retourne un résumé de la simulation"""
+        if self.results is None:
+            return "No simulation run yet."
+            
+        max_current = np.max(np.abs(self.results['current_physical']))
+        final_current = self.results['current_physical'][-1]
+        
+        summary = f"""
+=== SIMULATION SUMMARY ===
+Perturbation type: {self.perturbation_type}
+Simulation ID: {self.config.simulation_id}
+Energies processed: {self.config.Ne}
+Modes per energy: {self.config.n}
+Total models trained: {self.config.Ne * self.config.n}
+Max physical current: {max_current:.6e} A
+Final physical current: {final_current:.6e} A
+Results directory: {self.results_mgr.results_dir}
+        """
+        
+        return summary

modulation_da/quantum_system.py

@@ -0,0 +1,51 @@
+# quantum_system.py
+import numpy as np
+
+class QuantumSystem:
+    """Management of stationary quantum system"""
+    
+    def __init__(self, config):
+        self.config = config
+        self.n = config.n
+        self._setup_hamiltonian()
+        self._solve_stationary_states()
+    
+    def _setup_hamiltonian(self):
+        """Construction of Hamiltonian matrices"""
+        molE_norm = self.config.molE / self.config.E_scale
+        tm_norm = self.config.tm / self.config.E_scale
+        
+        self.H_0 = np.array([
+            [-molE_norm, 0.0, 0.0],
+            [0.0, molE_norm, tm_norm],
+            [0.0, tm_norm, molE_norm]
+        ], dtype=complex)
+        
+        # Self-energies
+        Gamma_norm = self.config.GammaL / self.config.E_scale
+        GammaR_norm = self.config.GammaR / self.config.E_scale
+        
+        self.SELF = np.array([
+            [-1j*Gamma_norm, 0, 0],
+            [0, -1j*Gamma_norm, 0],
+            [0, 0, -1j*GammaR_norm]
+        ], dtype=complex)
+    
+    def _solve_stationary_states(self):
+        """Resolution of stationary states"""
+        Ne, n = self.config.Ne, self.n
+        self.stock_psi = np.zeros((Ne, n, n), dtype=complex)
+        
+        GammaL_norm = self.config.GammaL / self.config.E_scale
+        vecs = [np.eye(n)[:, j:j+1] * np.sqrt(GammaL_norm) for j in range(n)]
+        
+        for i in range(Ne):
+            E_norm = self.config.E_min_norm + i * self.config.dE_norm
+            GR = np.linalg.inv(E_norm * np.eye(n) - self.H_0 - self.SELF)
+            
+            for j in range(n):
+                self.stock_psi[i, j, :] = (GR @ vecs[j])[:, 0]
+    
+    def fermi_dirac(self, E_norm):
+        """Fermi-Dirac distribution"""
+        return 1.0 / (1.0 + np.exp((E_norm - self.config.Ef_norm) / self.config.KBT_norm))

modulation_da/results_manager.py

@@ -0,0 +1,56 @@
+# results_manager.py
+import numpy as np
+import os
+from datetime import datetime
+
+class ResultsManager:
+    """Complete results management and saving"""   
+    
+    def __init__(self, config):
+        self.config = config
+        self.results_dir = f"RESULTS_{config.simulation_id}"
+        os.makedirs(self.results_dir, exist_ok=True)
+    
+    def save_simulation_parameters(self, perturbation_type):
+        """Saves simulation parameters"""
+        end_time = datetime.now()
+        duration = end_time - self.config.start_time
+        
+        params = {
+            'start_time': self.config.start_time.strftime("%Y-%m-%d %H:%M:%S"),
+            'end_time': end_time.strftime("%Y-%m-%d %H:%M:%S"),
+            'duration_seconds': duration.total_seconds(),
+            'perturbation_type': perturbation_type,
+            't_min_physical': self.config.t_min,
+            't_max_physical': self.config.t_max,
+            't_min_normalized': self.config.t_min_norm,
+            't_max_normalized': self.config.t_max_norm,
+            'E_scale': self.config.E_scale,
+            't_scale': self.config.t_scale,
+            'current_scale': self.config.current_scale,
+            'n_modes': self.config.n,
+            'n_energies': self.config.Ne
+        }
+        
+        with open(f"{self.results_dir}/simulation_parameters.txt", "w") as f:
+            f.write("=== QUANTUM PINN SIMULATION PARAMETERS ===\n\n")
+            for key, value in params.items():
+                f.write(f"{key}: {value}\n")
+    
+    def save_current_data(self, t_norm, t_physical, current_norm, current_physical):
+        """Saves current data"""
+        # Normalized data
+        np.savetxt(f"{self.results_dir}/current_normalized.dat",
+                  np.column_stack((t_norm, current_norm)),
+                  header="Time_normalized Current_normalized", fmt='%.10e')
+        
+        # Physical data
+        np.savetxt(f"{self.results_dir}/current_physical.dat",
+                  np.column_stack((t_physical, current_physical)),
+                  header="Time_seconds Current_amperes", fmt='%.10e')
+    
+    def save_pulse_data(self, t_norm, pulse_profile, perturbation_type):
+        """Saves pulse profile"""
+        np.savetxt(f"{self.results_dir}/pulse_profile_{perturbation_type}.dat",
+                  np.column_stack((t_norm, pulse_profile)),
+                  header="Time_normalized Pulse_amplitude", fmt='%.10e')

modulation_da/visualization.py

@@ -0,0 +1,48 @@
+# visualization.py
+import matplotlib.pyplot as plt
+import numpy as np
+
+class ResultsVisualizer:
+    """Complete visualization of results"""
+    
+    def __init__(self, results_manager):
+        self.results_manager = results_manager
+    
+    def plot_current_vs_time(self, t_norm, current_norm, t_physical, current_physical, perturbation_type):
+        """Plot of current as a function of time"""
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))
+        
+        # Normalized current
+        ax1.plot(t_norm, current_norm, 'b-', linewidth=2, label='Courant normalisé')
+        ax1.set_xlabel('Temps normalisé')
+        ax1.set_ylabel('Courant normalisé')
+        ax1.set_title(f'Courant normalisé - Perturbation {perturbation_type}')
+        ax1.grid(True, alpha=0.3)
+        ax1.legend()
+        
+        # Physical current
+        ax2.plot(t_physical * 1e15, current_physical, 'r-', linewidth=2, label='Courant physique')
+        ax2.set_xlabel('Temps (fs)')
+        ax2.set_ylabel('Courant (A)')
+        ax2.set_title(f'Courant physique - Perturbation {perturbation_type}')
+        ax2.grid(True, alpha=0.3)
+        ax2.legend()
+        
+        plt.tight_layout()
+        plt.savefig(f"{self.results_manager.results_dir}/current_vs_time_{perturbation_type}.png", 
+                   dpi=300, bbox_inches='tight')
+        plt.close()
+    
+    def plot_pulse_profile(self, t_norm, pulse_profile, perturbation_type):
+        """Plot of pulse profile"""
+        plt.figure(figsize=(10, 6))
+        plt.plot(t_norm, pulse_profile, 'g-', linewidth=2, 
+                label=f'Perturbation {perturbation_type}')
+        plt.xlabel('Temps normalisé')
+        plt.ylabel('Amplitude de perturbation')
+        plt.title(f'Profil de perturbation - {perturbation_type}')
+        plt.grid(True, alpha=0.3)
+        plt.legend()
+        plt.savefig(f"{self.results_manager.results_dir}/pulse_profile_{perturbation_type}.png",
+                   dpi=300, bbox_inches='tight')
+        plt.close()

modulation_da-0.0.1.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: modulation-da
+Version: 0.0.1
+Summary: A scientific computing package for simulating donor-acceptor modulation.
+Author-email: Delchere DON-TSA <dontsadelchere2000@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: tensorflow
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+
+# Simulation de la Modulation Donneur-Accepteur par Réseaux de Neurones Informés par la Physique (PINN)
+
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+## Description
+
+Ce projet met en œuvre un solveur basé sur les Réseaux de Neurones Informés par la Physique (PINNs) pour simuler et analyser les systèmes quantiques de type donneur-accepteur. Le code permet de configurer, perturber et résoudre les équations de Schrödinger pour de tels systèmes afin de calculer le courant résultant.
+
+## Table des matières
+
+- [Installation](#installation)
+- [Utilisation](#utilisation)
+- [Structure du Projet](#structure-du-projet)
+- [Dépendances](#dépendances)
+- [Auteurs](#auteurs)
+- [Licence](#licence)
+
+## Installation
+
+1.  Assurez-vous d'avoir les fichiers du projet dans un dossier sur votre machine.
+
+2.  Ouvrez un terminal, naviguez jusqu'au dossier racine du projet, puis installez les dépendances et le package :
+    ```sh
+    pip install -e .
+    ```
+
+## Utilisation
+
+Le script principal pour lancer une simulation est `main.py`. Vous pouvez le configurer et l'exécuter directement.
+
+```sh
+python main.py
+```
+
+Vous pouvez modifier le fichier `quantum_config.py` pour ajuster les paramètres de la simulation (potentiel, discrétisation, etc.) ou `perturbations.py` pour changer la nature des perturbations appliquées.
+
+Les résultats, y compris les graphiques, sont sauvegardés dans un dossier horodaté dans le répertoire `RESULTS_*`.
+
+## Structure du Projet
+
+Voici une description des fichiers clés du projet :
+
+-   `main.py`: Point d'entrée principal du programme. Orchestre la configuration, la simulation et la visualisation.
+-   `quantum_config.py`: Définit les constantes et les paramètres de la simulation quantique.
+-   `quantum_system.py`: Modélise le système quantique, y compris le potentiel et l'hamiltonien.
+-   `perturbations.py`: Gère l'application de perturbations au système.
+-   `pinn_model.py`: Contient l'architecture du modèle de réseau de neurones (PINN) avec TensorFlow.
+-   `quantum_solver.py`: Le cœur du solveur, qui utilise le PINN pour résoudre les équations.
+-   `current_calculator.py`: Calcule le courant à partir des résultats de la simulation.
+-   `results_manager.py`: S'occupe de la sauvegarde des résultats (données et figures).
+-   `visualization.py`: Génère les graphiques pour visualiser les résultats.
+-   `pyproject.toml`: Fichier de configuration du projet et de ses dépendances pour la distribution.
+
+## Dépendances
+
+Les principales dépendances de ce projet sont :
+
+-   `tensorflow`
+-   `numpy`
+-   `matplotlib`
+-   `scipy`
+
+## Auteurs
+
+-   **[Votre Nom]** - *[you@example.com](mailto:you@example.com)*
+
+Veuillez modifier cette section pour ajouter les auteurs.
+
+## Licence
+
+Ce projet est sous licence MIT. Voir le fichier `pyproject.toml` pour plus de détails.

modulation_da-0.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+modulation_da/__init__.py,sha256=E8_6ged9RNfh4IUcmwjt9EzQHG1u9Bm-ClP9v_i81Yc,159
+modulation_da/current_calculator.py,sha256=xhdkUoQR4egdZ-7vhM2KxN2AHzMVPB48JNDBTM94jsc,3125
+modulation_da/exempleBeltako.py,sha256=CO_n4-3rjfCtOQ7olVdKOAz_ZtRt6AeVJkow0LCCsQw,27013
+modulation_da/main.py,sha256=9DMR6N9i4jitMertg035Ay0Ey6Qf82YLY1CjjGtQ670,2450
+modulation_da/perturbations.py,sha256=3Qp4ZJE9RTDrSJamhCIbiv5dlrN_KTLcl5fCeN8oMpM,3988
+modulation_da/pinn_model.py,sha256=fzWelYobNQV_QXjayDZNs-JGi2GT-wbp1HeikoRt2sk,9726
+modulation_da/quantum_config.py,sha256=5hyJNF5a70Fv7e4fcpQbJNR5E9eDwaqtEaEEol1okkg,1668
+modulation_da/quantum_solver.py,sha256=dUKesjEb_8VR2din18SB2JcriHGYbtR7U5UM6mzKdSw,9866
+modulation_da/quantum_system.py,sha256=TqdD7-EDq05D9DjC3IbUQO4NJDK9BCX3nVX-coWa5oo,1790
+modulation_da/results_manager.py,sha256=ebg17tJVLAPLIWC4eJy3ljHqenvhAfoqEFhN--669k4,2410
+modulation_da/visualization.py,sha256=c3gBl5Ze9v8Q0vKMgTLO7H8_RB5QJnPBLIlHThiT-b8,2002
+modulation_da-0.0.1.dist-info/METADATA,sha256=ZREuci4FGm09XncX_-RwaHyWtVWg5kSd7OKq73dx1mw,3627
+modulation_da-0.0.1.dist-info/WHEEL,sha256=YLJXdYXQ2FQ0Uqn2J-6iEIC-3iOey8lH3xCtvFLkd8Q,91
+modulation_da-0.0.1.dist-info/entry_points.txt,sha256=wprE_oFV8W0RuVdTYzp0eAzsN73ceM5oxoVb_I2uJsg,58
+modulation_da-0.0.1.dist-info/top_level.txt,sha256=pEI_jdlzE5ji_jhW0D32NYmImPd5ImuuC_mxcxdC67A,14
+modulation_da-0.0.1.dist-info/RECORD,,

modulation_da-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (81.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

modulation_da-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+modulation-da = modulation_da.main:main

modulation_da-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+modulation_da