modulation-da 0.0.5
A scientific computing package for simulating donor-acceptor modulation.
License: MIT
Requires Python: >=3.8

# 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

`modulation-da` est une bibliothèque Python conçue pour simuler et analyser la modulation donneur-accepteur dans les systèmes quantiques en utilisant des Réseaux de Neurones Informés par la Physique (PINNs). Ce package fournit des outils pour configurer, perturber et résoudre les équations de Schrödinger afin de calculer le courant résultant. Il est idéal pour les chercheurs et les ingénieurs travaillant sur les systèmes quantiques, offrant une approche avancée pour la modélisation et l'analyse.

## Table des matières

- [Installation](#installation)
- [Utilisation](#utilisation)
- [Structure du Projet](#structure-du-projet)
- [Dépendances](#dépendances)
- [Auteurs](#auteurs)
- [Licence](#licence)

## Installation

1.  Ouvrez un terminal puis installez le package :
    ```sh
    pip install modulation-da
    ```

## Utilisation

Une fois le package `modulation-da` installé, vous pouvez l'utiliser directement via la ligne de commande. Le point d'entrée principal est `modulation-da`.

### Obtenir de l'aide

Pour afficher les options et commandes disponibles, utilisez l'option `--help` :

```sh
modulation-da --help
```

Ou pour obtenir de l'aide sur une commande spécifique, par exemple `run` :

```sh
modulation-da run --help
```

### Lancer une simulation

Pour lancer une simulation avec un type de perturbation spécifique, utilisez la commande `run`:

```sh
modulation-da run --perturbation-type gaussian
```

Vous pouvez choisir parmi les types de perturbation suivants : `gaussian`, `sinusoidal`, `rectangular`, `exponential`, `modulated_sinusoidal`.

Exemple pour une perturbation sinusoïdale :
```sh
modulation-da run --perturbation-type sinusoidal
```

### Utilisation en tant que bibliothèque (via import)

Au-delà de l'interface en ligne de commande, vous pouvez importer et utiliser les composants de `modulation-da` directement dans vos scripts Python pour une plus grande flexibilité ou pour l'intégration dans des projets existants.

Le composant principal pour lancer une simulation est `QuantumPINNSolver` que vous pouvez importer depuis `modulation_da.quantum_solver`.

Voici un exemple d'utilisation programmatique :

```python
from modulation_da.quantum_solver import QuantumPINNSolver

# Initialiser le solveur avec un type de perturbation
# Les types disponibles sont : 'gaussian', 'sinusoidal', 'rectangular', 'exponential', 'modulated_sinusoidal'
solver = QuantumPINNSolver(perturbation_type='gaussian')

print(f"Lancement de la simulation avec une perturbation de type : {solver.perturbation_type}")

try:
    # Exécuter la simulation complète
    solver.run_full_simulation()

    # Les résultats et les graphiques sont automatiquement sauvegardés
    # Si vous souhaitez un contrôle plus fin, vous pouvez appeler :
    # solver.save_results()
    # solver.generate_plots()

    print("Simulation terminée avec succès.")
    print("Résumé de la simulation :")
    print(solver.get_simulation_summary())

except Exception as e:
    print(f"Une erreur est survenue pendant la simulation : {e}")

```

### Résultats

Les résultats des simulations, y compris les données brutes et les figures générées, sont automatiquement sauvegardés dans un dossier horodaté. Ce dossier sera créé dans le répertoire `RESULTS_*` où vous exécutez la commande.

## 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
-   **Delchere DON-TSA** - *[dontsadelchere2000@gmail.com](dontsadelchere2000@gmail.com)*


## Licence

Ce projet est sous licence MIT. Voir le fichier `LICENSE` pour plus de détails.