simsite/backend/poisson/models.py

from django.db import models
import json


class PoissonSimulation(models.Model):
    """Modèle pour stocker les simulations de l'équation de Poisson"""
    
    STATUS_CHOICES = [
        ('pending', 'En attente'),
        ('running', 'En cours'),
        ('completed', 'Terminée'),
        ('failed', 'Échouée'),
    ]
    
    SOURCE_TYPE_CHOICES = [
        ('gaussian', 'Gaussienne'),
        ('constant', 'Constante'),
        ('sinusoidal', 'Sinusoïdale'),
        ('custom', 'Personnalisée'),
    ]
    
    BOUNDARY_TYPE_CHOICES = [
        ('dirichlet', 'Dirichlet (valeur fixée)'),
        ('neumann', 'Neumann (flux)'),
        ('mixed', 'Mixte'),
    ]
    
    name = models.CharField(max_length=255, verbose_name="Nom de la simulation")
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending')
    
    # Paramètres du domaine
    domain_x_min = models.FloatField(default=0.0)
    domain_x_max = models.FloatField(default=2.0)
    domain_y_min = models.FloatField(default=0.0)
    domain_y_max = models.FloatField(default=1.0)
    
    # Paramètres du maillage
    mesh_nx = models.IntegerField(default=64, verbose_name="Nombre d'éléments en x")
    mesh_ny = models.IntegerField(default=32, verbose_name="Nombre d'éléments en y")
    
    # Type de source
    source_type = models.CharField(max_length=20, choices=SOURCE_TYPE_CHOICES, default='gaussian')
    source_amplitude = models.FloatField(default=10.0)
    source_center_x = models.FloatField(default=0.5)
    source_center_y = models.FloatField(default=0.5)
    source_width = models.FloatField(default=0.02, verbose_name="Largeur (variance)")
    source_frequency = models.FloatField(default=1.0, verbose_name="Fréquence (pour sinusoïdale)")
    
    # Conditions aux limites - Dirichlet
    dirichlet_enabled = models.BooleanField(default=True)
    dirichlet_boundaries = models.CharField(max_length=50, default='left,right', 
                                            help_text="Frontières: left, right, top, bottom")
    dirichlet_value = models.FloatField(default=0.0)
    
    # Conditions aux limites - Neumann
    neumann_enabled = models.BooleanField(default=True)
    neumann_boundaries = models.CharField(max_length=50, default='top,bottom')
    neumann_type = models.CharField(max_length=20, default='sinusoidal', 
                                    choices=[('constant', 'Constante'), 
                                             ('sinusoidal', 'Sinusoïdale'),
                                             ('linear', 'Linéaire')])
    neumann_amplitude = models.FloatField(default=1.0)
    neumann_frequency = models.FloatField(default=5.0)
    
    # Résultats
    result_data = models.JSONField(null=True, blank=True)
    mesh_data = models.JSONField(null=True, blank=True)
    animation_frames = models.JSONField(null=True, blank=True)
    error_message = models.TextField(null=True, blank=True)
    
    # Statistiques de la solution
    solution_min = models.FloatField(null=True, blank=True)
    solution_max = models.FloatField(null=True, blank=True)
    computation_time = models.FloatField(null=True, blank=True)
    
    class Meta:
        ordering = ['-created_at']
        verbose_name = "Simulation Poisson"
        verbose_name_plural = "Simulations Poisson"
    
    def __str__(self):
        return f"{self.name} ({self.status})"
    
    def get_parameters_dict(self):
        """Retourne tous les paramètres sous forme de dictionnaire"""
        return {
            'domain': {
                'x_min': self.domain_x_min,
                'x_max': self.domain_x_max,
                'y_min': self.domain_y_min,
                'y_max': self.domain_y_max,
            },
            'mesh': {
                'nx': self.mesh_nx,
                'ny': self.mesh_ny,
            },
            'source': {
                'type': self.source_type,
                'amplitude': self.source_amplitude,
                'center_x': self.source_center_x,
                'center_y': self.source_center_y,
                'width': self.source_width,
                'frequency': self.source_frequency,
            },
            'dirichlet': {
                'enabled': self.dirichlet_enabled,
                'boundaries': self.dirichlet_boundaries.split(',') if self.dirichlet_boundaries else [],
                'value': self.dirichlet_value,
            },
            'neumann': {
                'enabled': self.neumann_enabled,
                'boundaries': self.neumann_boundaries.split(',') if self.neumann_boundaries else [],
                'type': self.neumann_type,
                'amplitude': self.neumann_amplitude,
                'frequency': self.neumann_frequency,
            },
        }