materials_config.py

import numpy as np

MATERIALS = {
    "Acier": {
        "lambda": 1.21,
        "mu": 0.77,
        "description": "Alliage fer-carbone, haute résistance",
        "E_GPa": 200,
        "nu": 0.30,
    },
    "Aluminium": {
        "lambda": 0.52,
        "mu": 0.26,
        "description": "Métal léger, bonne conductivité thermique",
        "E_GPa": 70,
        "nu": 0.33,
    },
    "Béton": {
        "lambda": 0.08,
        "mu": 0.13,
        "description": "Matériau de construction, comportement fragile",
        "E_GPa": 30,
        "nu": 0.20,
    },
    "Cuivre": {
        "lambda": 0.89,
        "mu": 0.42,
        "description": "Excellente conductivité électrique et thermique",
        "E_GPa": 110,
        "nu": 0.34,
    },
    "Titane": {
        "lambda": 0.82,
        "mu": 0.39,
        "description": "Léger et résistant, applications aérospatiales",
        "E_GPa": 116,
        "nu": 0.32,
    },
    "Verre": {
        "lambda": 0.42,
        "mu": 0.29,
        "description": "Matériau amorphe, fragile",
        "E_GPa": 70,
        "nu": 0.22,
    },
    "Caoutchouc": {
        "lambda": 10.0,
        "mu": 0.01,
        "description": "Élastomère, quasi-incompressible",
        "E_GPa": 0.01,
        "nu": 0.49,
    },
    "Bois (parallèle)": {
        "lambda": 0.15,
        "mu": 0.07,
        "description": "Matériau anisotrope simplifié, fibres parallèles",
        "E_GPa": 12,
        "nu": 0.30,
    },
    "Magnésium": {
        "lambda": 0.35,
        "mu": 0.17,
        "description": "Métal ultra-léger",
        "E_GPa": 45,
        "nu": 0.29,
    },
    "Laiton": {
        "lambda": 0.75,
        "mu": 0.36,
        "description": "Alliage cuivre-zinc",
        "E_GPa": 100,
        "nu": 0.34,
    },
    "Nickel": {
        "lambda": 1.12,
        "mu": 0.52,
        "description": "Métal résistant à la corrosion",
        "E_GPa": 170,
        "nu": 0.31,
    },
    "Zinc": {
        "lambda": 0.45,
        "mu": 0.22,
        "description": "Métal de revêtement",
        "E_GPa": 60,
        "nu": 0.30,
    },
    "Plomb": {
        "lambda": 0.28,
        "mu": 0.08,
        "description": "Métal lourd, malléable",
        "E_GPa": 16,
        "nu": 0.43,
    },
    "Étain": {
        "lambda": 0.32,
        "mu": 0.15,
        "description": "Métal mou, soudure",
        "E_GPa": 47,
        "nu": 0.34,
    },
    "Or": {
        "lambda": 1.35,
        "mu": 0.31,
        "description": "Métal précieux, très ductile",
        "E_GPa": 79,
        "nu": 0.44,
    },
    "Argent": {
        "lambda": 0.68,
        "mu": 0.27,
        "description": "Meilleure conductivité électrique",
        "E_GPa": 83,
        "nu": 0.37,
    },
    "Platine": {
        "lambda": 1.82,
        "mu": 0.62,
        "description": "Métal précieux, haute résistance",
        "E_GPa": 168,
        "nu": 0.38,
    },
    "Tungstène": {
        "lambda": 1.95,
        "mu": 1.08,
        "description": "Métal le plus résistant, point de fusion élevé",
        "E_GPa": 411,
        "nu": 0.28,
    },
    "Composite carbone": {
        "lambda": 0.05,
        "mu": 0.55,
        "description": "Fibres de carbone, haute résistance/poids",
        "E_GPa": 150,
        "nu": 0.07,
    },
    "Mousse polymère": {
        "lambda": 0.001,
        "mu": 0.001,
        "description": "Matériau cellulaire, très léger",
        "E_GPa": 0.003,
        "nu": 0.30,
    },
}


def calculate_real_params_from_E_nu(E_GPa, nu):
    """
    Calcule les paramètres de Lamé réels à partir du module d'Young E et du coefficient de Poisson ν.

    Relations:
        λ = E·ν / ((1+ν)(1-2ν))
        μ = E / (2(1+ν))

    Args:
        E_GPa: Module d'Young en GPa
        nu: Coefficient de Poisson (sans dimension)

    Returns:
        tuple: (lambda_real_GPa, mu_real_GPa)
    """
    if nu >= 0.5:
        nu = 0.499

    lambda_real = E_GPa * nu / ((1 + nu) * (1 - 2 * nu))
    mu_real = E_GPa / (2 * (1 + nu))

    return lambda_real, mu_real


def calculate_E_nu_from_lame(lambda_val, mu_val):
    """
    Calcule E et ν à partir des paramètres de Lamé.

    Relations:
        E = μ(3λ + 2μ) / (λ + μ)
        ν = λ / (2(λ + μ))

    Args:
        lambda_val: Premier paramètre de Lamé
        mu_val: Deuxième paramètre de Lamé (module de cisaillement)

    Returns:
        tuple: (E, nu)
    """
    E = mu_val * (3 * lambda_val + 2 * mu_val) / (lambda_val + mu_val)
    nu = lambda_val / (2 * (lambda_val + mu_val))
    return E, nu


def enrich_material_info(name):
    """
    Enrichit les informations d'un matériau avec les valeurs réelles et facteurs de conversion.

    Pour chaque matériau, calcule:
    - lambda_real: Valeur réelle de λ en GPa (à partir de E et ν)
    - mu_real: Valeur réelle de μ en GPa (à partir de E et ν)
    - lambda_factor: Facteur de conversion = lambda_real / lambda_norm
    - mu_factor: Facteur de conversion = mu_real / mu_norm

    Args:
        name: Nom du matériau

    Returns:
        dict: Informations complètes du matériau
    """
    if name not in MATERIALS:
        raise ValueError(f"Matériau inconnu: {name}")

    info = MATERIALS[name].copy()

    E_GPa = info["E_GPa"]
    nu = info["nu"]
    lambda_norm = info["lambda"]
    mu_norm = info["mu"]

    lambda_real, mu_real = calculate_real_params_from_E_nu(E_GPa, nu)

    if lambda_norm != 0:
        lambda_factor = lambda_real / lambda_norm
    else:
        lambda_factor = 0.0

    if mu_norm != 0:
        mu_factor = mu_real / mu_norm
    else:
        mu_factor = 0.0

    info["lambda_real_GPa"] = lambda_real
    info["mu_real_GPa"] = mu_real
    info["lambda_factor"] = lambda_factor
    info["mu_factor"] = mu_factor

    return info


def get_material_names():
    return list(MATERIALS.keys())


def get_material_params(name):
    if name not in MATERIALS:
        raise ValueError(f"Matériau inconnu: {name}")
    return MATERIALS[name]["lambda"], MATERIALS[name]["mu"]


def get_material_info(name):
    if name not in MATERIALS:
        raise ValueError(f"Matériau inconnu: {name}")
    return MATERIALS[name]


def get_enriched_material_info(name):
    return enrich_material_info(name)


def denormalize_identified_params(lambda_norm_ident, mu_norm_ident, name):
    """
    Dénormalise les paramètres identifiés en utilisant les facteurs du matériau.

    Args:
        lambda_norm_ident: λ normalisé identifié par le PINN
        mu_norm_ident: μ normalisé identifié par le PINN
        name: Nom du matériau

    Returns:
        dict: Paramètres dénormalisés avec comparaison
    """
    info = enrich_material_info(name)

    lambda_real_ident = lambda_norm_ident * info["lambda_factor"]
    mu_real_ident = mu_norm_ident * info["mu_factor"]

    lambda_real_true = info["lambda_real_GPa"]
    mu_real_true = info["mu_real_GPa"]

    lambda_error_pct = (
        abs(lambda_real_ident - lambda_real_true) / lambda_real_true * 100
        if lambda_real_true != 0
        else 0
    )
    mu_error_pct = (
        abs(mu_real_ident - mu_real_true) / mu_real_true * 100
        if mu_real_true != 0
        else 0
    )

    return {
        "lambda_norm_ident": lambda_norm_ident,
        "mu_norm_ident": mu_norm_ident,
        "lambda_real_ident_GPa": lambda_real_ident,
        "mu_real_ident_GPa": mu_real_ident,
        "lambda_real_true_GPa": lambda_real_true,
        "mu_real_true_GPa": mu_real_true,
        "lambda_error_pct": lambda_error_pct,
        "mu_error_pct": mu_error_pct,
        "lambda_factor": info["lambda_factor"],
        "mu_factor": info["mu_factor"],
    }


def params_to_filename(lam, mu):
    return f"model_l{lam:.3f}_m{mu:.3f}.pt"


def generate_materials_table():
    """
    Génère un tableau récapitulatif de tous les matériaux avec leurs propriétés.
    """
    print("\n" + "=" * 120)
    print(
        f"{'Matériau':<20} {'E (GPa)':<10} {'ν':<6} {'λ_norm':<10} {'μ_norm':<10} {'λ_réel (GPa)':<15} {'μ_réel (GPa)':<15} {'Fact. λ':<12} {'Fact. μ':<12}"
    )
    print("=" * 120)

    for name in MATERIALS.keys():
        info = enrich_material_info(name)
        print(
            f"{name:<20} {info['E_GPa']:<10.1f} {info['nu']:<6.2f} {info['lambda']:<10.3f} {info['mu']:<10.3f} {info['lambda_real_GPa']:<15.2f} {info['mu_real_GPa']:<15.2f} {info['lambda_factor']:<12.2f} {info['mu_factor']:<12.2f}"
        )

    print("=" * 120 + "\n")


if __name__ == "__main__":
    generate_materials_table()