modulation-da 0.0.1__tar.gz

modulation_da-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,71 @@
+# 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/modulation_da/__init__.py

@@ -0,0 +1,7 @@
+# modulation_donneur_accepteur_uniquement/__init__.py
+
+"""
+A scientific computing package for simulating donor-acceptor modulation.
+"""
+
+__version__ = "0.0.1"

modulation_da-0.0.1/modulation_da/current_calculator.py

@@ -0,0 +1,71 @@
+# current_calculator.py
+import tensorflow as tf
+import numpy as np
+
+class CurrentCalculator:
+    """Complete calculation of quantum currents"""
+    
+    def __init__(self, config, system):
+        self.config = config
+        self.system = system
+    
+    def compute_current_contribution(self, model, i_energy, j_mode, perturbation_manager, perturbation_type):
+        """Calculates current contribution for a specific mode/energy"""
+        E_norm = self.config.E_min_norm + i_energy * self.config.dE_norm
+        psi_st = self.system.stock_psi[i_energy, j_mode, :].reshape((-1, 1))
+        psi_st_tensor = tf.convert_to_tensor(psi_st, dtype=tf.complex64)
+        
+        # Prédiction
+        t_pred, psi_total, HT_pred = self.predict_wavefunction(model, E_norm, psi_st_tensor, perturbation_manager, perturbation_type)
+        
+         # Current calculation
+        fermi_factor = self.system.fermi_dirac(E_norm)
+        current_mode = self._compute_mode_current(psi_total, HT_pred, fermi_factor)
+        
+        return current_mode, t_pred
+    
+    def predict_wavefunction(self, model, E_norm, psi_st_tensor, perturbation_manager, perturbation_type):
+        """Predicts the complete wavefunction"""
+        t_pred_norm_vals = np.linspace(self.config.t_min_norm, self.config.t_max_norm, 5000)
+        t_pred_norm = tf.convert_to_tensor(t_pred_norm_vals.reshape(-1, 1), dtype=tf.float32)
+        
+        # Hamiltonians for prediction
+        HP_pred_list = []
+        for s in range(len(t_pred_norm_vals)):
+            t_s_norm = t_pred_norm_vals[s]
+            HP_s = perturbation_manager.get_perturbation(t_s_norm, perturbation_type)
+            HP_pred_list.append(HP_s)
+        
+        HP_pred = tf.convert_to_tensor(np.stack(HP_pred_list), dtype=tf.complex64)
+        
+        # Network prediction
+        psi_pred = model(t_pred_norm)
+        u_pred = psi_pred[:, :self.config.n]
+        v_pred = psi_pred[:, self.config.n:]
+        psi_p = tf.complex(u_pred, v_pred)
+        
+        # Add stationary state
+        phase = tf.exp(-1j * tf.cast(E_norm, tf.complex64) * 
+                      tf.cast(t_pred_norm_vals, tf.complex64))
+        phase = tf.expand_dims(phase, axis=-1)
+        
+        psi_st_broadcast = tf.transpose(psi_st_tensor)
+        psi_total = psi_p + phase * psi_st_broadcast
+        
+        # Total Hamiltonian
+        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), len(t_pred_norm_vals), axis=0)
+        SELF_pred = tf.repeat(tf.expand_dims(SELF_tensor, axis=0), len(t_pred_norm_vals), axis=0)
+        HT_pred = HP_pred + H_0_pred + SELF_pred
+        
+        return t_pred_norm_vals, psi_total, HT_pred
+    
+    def _compute_mode_current(self, psi_total, HT_pred, fermi_factor):
+        """Calculates current for a specific mode"""
+        psi1_conj = tf.math.conj(psi_total[:, 1])
+        H12 = HT_pred[:, 1, 2]
+        psi2 = psi_total[:, 2]
+        
+        return fermi_factor * psi1_conj * H12 * psi2