code python pour la resolution du modele mathematique cardiaque

code python pour la resolution du modele mathematique cardiaque

La résolution d'un modèle mathématique cardiaque peut être complexe et dépend du modèle spécifique que vous souhaitez utiliser. Un des modèles les plus couramment utilisés pour simuler l'activité électrique du cœur est le modèle de Hodgkin-Huxley ou ses variantes adaptées pour les cellules cardiaques, comme le modèle de Luo-Rudy.

Pour illustrer cela, je vais vous montrer un exemple simplifié en utilisant le modèle de Hodgkin-Huxley. Ce modèle décrit comment les potentiels d'action dans les neurones (ou cellules cardiaques) sont initiés et propagés par les courants ioniques.

Voici un exemple de code Python pour résoudre le modèle de Hodgkin-Huxley en utilisant la méthode d'Euler pour l'intégration numérique :

import numpy as np
import matplotlib.pyplot as plt

# Constantes du modèle de Hodgkin-Huxley
C_m = 1.0  # Capacité membranaire, en uF/cm^2
g_Na = 120.0  # Conductance maximale du sodium, en mS/cm^2
g_K = 36.0  # Conductance maximale du potassium, en mS/cm^2
g_L = 0.3  # Conductance de fuite, en mS/cm^2
E_Na = 50.0  # Potentiel d'équilibre du sodium, en mV
E_K = -77.0  # Potentiel d'équilibre du potassium, en mV
E_L = -54.387  # Potentiel d'��quilibre de fuite, en mV

# Paramètres de simulation
t_max = 50.0  # Durée de la simulation, en ms
dt = 0.01  # Pas de temps, en ms
time = np.arange(0, t_max, dt)

# Courant d'injection
I_ext = np.zeros_like(time)
I_ext[1000:4000] = 10.0  # Courant d'injection, en uA/cm^2

# Fonctions auxiliaires pour les variables de porte
def alpha_n(V):
    return 0.01 * (V + 55) / (1 - np.exp(-0.1 * (V + 55)))

def beta_n(V):
    return 0.125 * np.exp(-0.0125 * (V + 65))

def alpha_m(V):
    return 0.1 * (V + 40) / (1 - np.exp(-0.1 * (V + 40)))

def beta_m(V):
    return 4.0 * np.exp(-0.0556 * (V + 65))

def alpha_h(V):
    return 0.07 * np.exp(-0.05 * (V + 65))

def beta_h(V):
    return 1 / (1 + np.exp(-0.1 * (V + 35)))

# Initialisation des variables
V = -65.0  # Potentiel de membrane initial, en mV
n = alpha_n(V) / (alpha_n(V) + beta_n(V))
m = alpha_m(V) / (alpha_m(V) + beta_m(V))
h = alpha_h(V) / (alpha_h(V) + beta_h(V))

V_trace = []
n_trace = []
m_trace = []
h_trace = []

# Boucle de simulation
for t in time:
    # Courants ioniques
    I_Na = g_Na * m**3 * h * (V - E_Na)
    I_K = g_K * n**4 * (V - E_K)
    I_L = g_L * (V - E_L)
    
    # Équation différentielle pour le potentiel de membrane
    dVdt = (I_ext[int(t/dt)] - I_Na - I_K - I_L) / C_m
    V += dVdt * dt
    
    # Équations différentielles pour les variables de porte
    dn = (alpha_n(V) * (1 - n) - beta_n(V) * n) * dt
    dm = (alpha_m(V) * (1 - m) - beta_m(V) * m) * dt
    dh = (alpha_h(V) * (1 - h) - beta_h(V) * h) * dt
    
    n += dn
    m += dm
    h += dh
    
    # Enregistrement des traces
    V_trace.append(V)
    n_trace.append(n)
    m_trace.append(m)
    h_trace.append(h)

# Affichage des résultats
plt.figure(figsize=(10, 6))
plt.subplot(2, 1, 1)
plt.plot(time, V_trace, label='Potentiel de membrane (V)')
plt.xlabel('Temps (ms)')
plt.ylabel('Potentiel (mV)')
plt.legend()

plt.subplot(2, 1, 2)
plt.plot(time, n_trace, label='n')
plt.plot(time, m_trace, label='m')
plt.plot(time, h_trace, label='h')
plt.xlabel('Temps (ms)')
plt.ylabel('Variables de porte')
plt.legend()

plt.tight_layout()
plt.show()

Ce code simule l'activité électrique d'une cellule en utilisant le modèle de Hodgkin-Huxley. Il intègre les équations différentielles en utilisant la méthode d'Euler et trace le potentiel de membrane ainsi que les variables de porte au fil du temps.

Pour des modèles cardiaques plus complexes, comme le modèle de Luo-Rudy, vous devrez adapter les équations et les paramètres en conséquence. Les modèles cardiaques peuvent également inclure des aspects supplémentaires comme la dynamique calcique, les interactions entre les cellules, et la modélisation des tissus cardiaques