pdesolver 0.1.0__tar.gz

pdesolver-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: pdesolver
+Version: 0.1.0
+Summary: Solver simbólico para equações diferenciais parciais (PDEs) com discretização por diferenças finitas
+License: MIT
+Project-URL: Repository, https://github.com/maiocacedo/PDESsolver
+Keywords: pde,differential equations,numerical methods,finite differences,solver
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: sympy>=1.12
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: scipy>=1.10
+Provides-Extra: gpu
+Requires-Dist: cupy-cuda12x; extra == "gpu"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# pdesolver
+
+Solver simbólico para equações diferenciais parciais (PDEs) usando discretização por diferenças finitas.
+
+## Instalação
+
+```bash
+pip install pdesolver
+```
+
+Para suporte a GPU (CUDA 12):
+
+```bash
+pip install pdesolver[gpu]
+```
+
+## Uso rápido
+
+```python
+from pdesolver import PDE, PDES
+
+# Equação do calor: du/dt = d2u/dt2
+pde = PDE(
+    eq="duxy/dt = d2uxy/dx2",
+    func="u",
+    sp_var=["x"],
+    ivar=["t"],
+    ivar_boundary=[(0, 1)],
+    expr_ic="sin(pi*x)",
+    west_bd="Dirichlet", west_func_bd="0",
+    east_bd="Dirichlet", east_func_bd="0",
+)
+
+sistema = PDES(pdes=[pde], disc_n=[50])
+sistema.discretize(method='central')
+sistema.solve(method='bdf2', tf=0.1, nt=100)
+sistema.visualize(mode='plot1d_all', tf=0.1)
+```
+
+## Métodos disponíveis
+
+### Discretização espacial
+- `method='central'` — diferenças centrais (padrão)
+- `method='forward'` — diferenças progressivas
+- `method='backward'` — diferenças regressivas
+
+### Integração temporal
+- `method='bdf2'` — BDF-2 implícito (padrão, recomendado)
+- `method='CN'` — Crank-Nicolson
+- `method='RKF'` — Runge-Kutta-Fehlberg 4(5) com CUDA *(requer cupy)*
+
+### Condições de contorno
+- `Dirichlet` — valor prescrito
+- `Neumann` — fluxo prescrito
+- `Robin` — combinação linear
+
+### Visualização
+- `'plot1d'` / `'plot1d_all'` — perfis 1D
+- `'heatmap1d'` — mapa espaciotemporal 1D
+- `'animation1d'` — animação 1D
+- `'heatmap'` — mapa de calor 2D
+- `'plot3d'` / `'animation3d'` — superfície 3D
+
+## Salvar e carregar resultados
+
+```python
+sistema.save_to_json("resultado.json")
+
+sistema2 = PDES.load_from_json("resultado.json")
+```

pdesolver-0.1.0/README.md

@@ -0,0 +1,70 @@
+# pdesolver
+
+Solver simbólico para equações diferenciais parciais (PDEs) usando discretização por diferenças finitas.
+
+## Instalação
+
+```bash
+pip install pdesolver
+```
+
+Para suporte a GPU (CUDA 12):
+
+```bash
+pip install pdesolver[gpu]
+```
+
+## Uso rápido
+
+```python
+from pdesolver import PDE, PDES
+
+# Equação do calor: du/dt = d2u/dt2
+pde = PDE(
+    eq="duxy/dt = d2uxy/dx2",
+    func="u",
+    sp_var=["x"],
+    ivar=["t"],
+    ivar_boundary=[(0, 1)],
+    expr_ic="sin(pi*x)",
+    west_bd="Dirichlet", west_func_bd="0",
+    east_bd="Dirichlet", east_func_bd="0",
+)
+
+sistema = PDES(pdes=[pde], disc_n=[50])
+sistema.discretize(method='central')
+sistema.solve(method='bdf2', tf=0.1, nt=100)
+sistema.visualize(mode='plot1d_all', tf=0.1)
+```
+
+## Métodos disponíveis
+
+### Discretização espacial
+- `method='central'` — diferenças centrais (padrão)
+- `method='forward'` — diferenças progressivas
+- `method='backward'` — diferenças regressivas
+
+### Integração temporal
+- `method='bdf2'` — BDF-2 implícito (padrão, recomendado)
+- `method='CN'` — Crank-Nicolson
+- `method='RKF'` — Runge-Kutta-Fehlberg 4(5) com CUDA *(requer cupy)*
+
+### Condições de contorno
+- `Dirichlet` — valor prescrito
+- `Neumann` — fluxo prescrito
+- `Robin` — combinação linear
+
+### Visualização
+- `'plot1d'` / `'plot1d_all'` — perfis 1D
+- `'heatmap1d'` — mapa espaciotemporal 1D
+- `'animation1d'` — animação 1D
+- `'heatmap'` — mapa de calor 2D
+- `'plot3d'` / `'animation3d'` — superfície 3D
+
+## Salvar e carregar resultados
+
+```python
+sistema.save_to_json("resultado.json")
+
+sistema2 = PDES.load_from_json("resultado.json")
+```

pdesolver-0.1.0/pdesolver/Auxs/FuncAux.py

@@ -0,0 +1,24 @@
+import re
+
+import sympy as sp
+from sympy.parsing.sympy_parser import parse_expr
+
+def symbol_references(in_list):
+    slist = []
+
+    for e in in_list:
+        globals()[e] = sp.Symbol(e)
+        slist.append(e)
+    return slist
+
+def d_dt(expr_str: str) -> str:
+    t = sp.Symbol('t')
+    try:
+        e = parse_expr(expr_str, evaluate=False)
+        return str(sp.diff(e, t))
+    except Exception:
+        return expr_str
+
+def repl_symbol(expr: str, sym: str, repl: str) -> str:
+    pattern = rf'(?<![A-Za-z0-9_]){sym}(?![A-Za-z0-9_])'
+    return re.sub(pattern, repl, expr)

pdesolver-0.1.0/pdesolver/Auxs/PDESEncoder.py

@@ -0,0 +1,13 @@
+import json
+import numpy as np
+import sympy as sp
+
+class PDESEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        if isinstance(obj, sp.Basic):
+            return str(obj)
+        if hasattr(obj, '__dict__'):
+            return obj.__dict__
+        return super().default(obj)

pdesolver-0.1.0/pdesolver/Auxs/Visualize.py

@@ -0,0 +1,266 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+
+
+def visualize(pdes_obj, mode='heatmap', func_idx=0, time_step=-1, **kwargs):
+
+    if pdes_obj.results is None:
+        print("Erro: rode .solve() antes de visualizar.")
+        return
+
+    _, historico = pdes_obj.results
+
+    if not historico or not historico[func_idx]:
+        print("Erro: histórico vazio.")
+        return
+
+    if _is_1d(pdes_obj):
+        x = _get_x1d(pdes_obj)
+        if mode in ('plot1d', 'plot'):
+            plot1d(historico, x, pdes_obj.funcs, func_idx, time_step, **kwargs)
+        elif mode == 'plot1d_all':
+            plot1d_all(historico, x, pdes_obj.funcs, func_idx, **kwargs)
+        elif mode == 'heatmap1d':
+            heatmap1d(historico, x, pdes_obj.funcs, pdes_obj.pdes, func_idx, **kwargs)
+        elif mode == 'animation1d':
+            animate1d(historico, x, pdes_obj.funcs, func_idx, **kwargs)
+        else:
+            print(f"Modo '{mode}' não reconhecido para 1D. "
+                  f"Use: 'plot1d', 'plot1d_all', 'heatmap1d', 'animation1d'.")
+        return
+
+    nx, ny = pdes_obj.disc_n
+    x = np.linspace(0, 1, nx)
+    y = np.linspace(0, 1, ny)
+    X, Y = np.meshgrid(x, y, indexing='ij')
+
+    if mode == 'heatmap':
+        plot_heatmap(historico, X, Y, pdes_obj.funcs, pdes_obj.disc_n, func_idx, time_step)
+    elif mode == 'animation':
+        animate2d(historico, X, Y, pdes_obj.funcs, pdes_obj.disc_n, func_idx, **kwargs)
+    elif mode == 'plot3d':
+        plot3d(historico, X, Y, pdes_obj.funcs, pdes_obj.disc_n, func_idx, time_step, **kwargs)
+    elif mode == 'animation3d':
+        animate3d(historico, X, Y, pdes_obj.funcs, pdes_obj.disc_n, func_idx, **kwargs)
+    else:
+        print(f"Modo '{mode}' desconhecido para 2D. "
+              f"Use: 'heatmap', 'animation', 'plot3d', 'animation3d'.")
+
+
+def _is_1d(pdes_obj):
+    return len(pdes_obj.disc_n) == 1
+
+
+def _get_x1d(pdes_obj):
+    a, b = pdes_obj.pdes[0].ivar_boundary[0]
+    return np.linspace(a, b, pdes_obj.disc_n[0])
+
+
+def plot1d(historico, x, funcs, func_idx, time_step, **kwargs):
+    color = kwargs.get('color', 'steelblue')
+    lw    = kwargs.get('lw', 2)
+
+    data  = np.array(historico[func_idx][time_step])
+    label = time_step if time_step >= 0 else len(historico[func_idx]) + time_step
+
+    fig, ax = plt.subplots(figsize=(7, 4))
+    ax.plot(x, data, color=color, linewidth=lw, label=f't = passo {label}')
+    ax.set_xlabel('x')
+    ax.set_ylabel(funcs[func_idx])
+    ax.set_title(f"Perfil de {funcs[func_idx]} — passo {label}")
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    plt.show()
+
+
+def plot1d_all(historico, x, funcs, func_idx, **kwargs):
+    n_profiles = kwargs.get('n_profiles', 10)
+    cmap       = kwargs.get('cmap', 'viridis')
+    lw         = kwargs.get('lw', 1.5)
+    tf_real    = kwargs.get('tf', None)
+
+    n_passos = len(historico[func_idx])
+    indices  = np.linspace(0, n_passos - 1, n_profiles, dtype=int)
+    cm       = plt.get_cmap(cmap)
+    colors   = [cm(i / (n_profiles - 1)) for i in range(n_profiles)]
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+
+    for idx_cor, idx_passo in enumerate(indices):
+        data = np.array(historico[func_idx][idx_passo])
+        if tf_real is not None:
+            t_val = tf_real * idx_passo / (n_passos - 1)
+            lbl   = f't = {t_val:.2f}'
+        else:
+            lbl = f'passo {idx_passo}'
+        ax.plot(x, data, color=colors[idx_cor], linewidth=lw, label=lbl)
+
+    ax.set_xlabel('x')
+    ax.set_ylabel(funcs[func_idx])
+    ax.set_title(f"Evolução de {funcs[func_idx]} ao longo do tempo")
+    ax.legend(fontsize=8, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=0, vmax=1))
+    sm.set_array([])
+    cbar = plt.colorbar(sm, ax=ax, pad=0.02)
+    cbar.set_label('t / tf')
+
+    plt.tight_layout()
+    plt.show()
+
+
+def heatmap1d(historico, x, funcs, pdes, func_idx, **kwargs):
+    cmap    = kwargs.get('cmap', 'viridis')
+    tf_real = kwargs.get('tf', None)
+
+    matriz   = np.array(historico[func_idx])
+    n_passos = matriz.shape[0]
+    t_max    = tf_real if tf_real is not None else n_passos - 1
+    a, b     = pdes[0].ivar_boundary[0]
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    im = ax.imshow(
+        matriz.T,
+        aspect='auto',
+        origin='lower',
+        extent=[0, t_max, a, b],
+        cmap=cmap
+    )
+    ax.set_xlabel('t')
+    ax.set_ylabel('x')
+    ax.set_title(f"Evolução espaciotemporal de {funcs[func_idx]}")
+    plt.colorbar(im, ax=ax, label=funcs[func_idx])
+    plt.tight_layout()
+    plt.show()
+
+
+def animate1d(historico, x, funcs, func_idx, **kwargs):
+    frames_step = kwargs.get('frames_step', 1)
+    interval    = kwargs.get('interval', 50)
+    color       = kwargs.get('color', 'steelblue')
+    lw          = kwargs.get('lw', 2)
+    tf_real     = kwargs.get('tf', None)
+
+    n_passos = len(historico[func_idx])
+    frames   = list(range(0, n_passos, frames_step))
+
+    todos  = np.concatenate([historico[func_idx][f] for f in frames])
+    y_min, y_max = todos.min(), todos.max()
+    margem = (y_max - y_min) * 0.05 or 0.1
+
+    fig, ax = plt.subplots(figsize=(8, 4))
+    linha,  = ax.plot(x, historico[func_idx][0], color=color, linewidth=lw)
+    ax.set_xlim(x[0], x[-1])
+    ax.set_ylim(y_min - margem, y_max + margem)
+    ax.set_xlabel('x')
+    ax.set_ylabel(funcs[func_idx])
+    ax.grid(True, alpha=0.3)
+    titulo = ax.set_title('')
+
+    def update(frame_idx):
+        passo = frames[frame_idx]
+        linha.set_ydata(np.array(historico[func_idx][passo]))
+        if tf_real is not None:
+            t_val = tf_real * passo / (n_passos - 1)
+            titulo.set_text(f"{funcs[func_idx]} — t = {t_val:.3f}")
+        else:
+            titulo.set_text(f"{funcs[func_idx]} — passo {passo}")
+        return linha, titulo
+
+    anim = FuncAnimation(fig, update, frames=len(frames),
+                         interval=interval, blit=True)
+    plt.tight_layout()
+    plt.show()
+
+def plot_heatmap(historico, X, Y, funcs, disc_n, func_idx, time_step):
+    data = np.array(historico[func_idx][time_step]).reshape(disc_n)
+    plt.figure(figsize=(7, 6))
+    contorno = plt.contourf(X, Y, data, levels=30, cmap='hot')
+    plt.title(f"Distribuição de {funcs[func_idx]} no passo {time_step}")
+    plt.colorbar(contorno)
+    plt.show()
+
+
+def animate2d(historico, X, Y, funcs, disc_n, func_idx, **kwargs):
+    frames_step = kwargs.get('frames_step', 1)
+    interval    = kwargs.get('interval', 50)
+
+    fig, ax = plt.subplots(figsize=(7, 6))
+    Z_ini   = np.array(historico[func_idx][0]).reshape(disc_n)
+    contorno = ax.contourf(X, Y, Z_ini, levels=30, cmap='hot')
+    fig.colorbar(contorno, ax=ax)
+
+    def update(frame):
+        ax.clear()
+        Z    = np.array(historico[func_idx][frame]).reshape(disc_n)
+        cont = ax.contourf(X, Y, Z, levels=30, cmap='hot')
+        ax.set_title(f"Evolução de {funcs[func_idx]} - Passo {frame}")
+        ax.set_xlabel('x')
+        ax.set_ylabel('y')
+        return cont,
+
+    frames_list = range(0, len(historico[func_idx]), frames_step)
+    anim = FuncAnimation(fig, update, frames=frames_list,
+                         interval=interval, blit=False)
+    plt.show()
+
+
+def plot3d(historico, X, Y, funcs, disc_n, func_idx, time_step, **kwargs):
+    cmap  = kwargs.get('cmap', 'hot')
+    alpha = kwargs.get('alpha', 1.0)
+    elev  = kwargs.get('elev', 30)
+    azim  = kwargs.get('azim', -60)
+
+    data  = np.array(historico[func_idx][time_step]).reshape(disc_n)
+    label = time_step if time_step >= 0 else len(historico[func_idx]) + time_step
+
+    fig = plt.figure(figsize=(8, 6))
+    ax  = fig.add_subplot(111, projection='3d')
+    ax.plot_surface(X, Y, data, cmap=cmap, alpha=alpha)
+    ax.set_title(f"Superfície 3D de {funcs[func_idx]} - Passo {label}")
+    ax.set_xlabel('x')
+    ax.set_ylabel('y')
+    ax.set_zlabel(str(funcs[func_idx]))
+    ax.view_init(elev=elev, azim=azim)
+    plt.tight_layout()
+    plt.show()
+
+
+def animate3d(historico, X, Y, funcs, disc_n, func_idx, **kwargs):
+    frames_step = kwargs.get('frames_step', 1)
+    interval    = kwargs.get('interval', 50)
+    cmap        = kwargs.get('cmap', 'hot')
+    alpha       = kwargs.get('alpha', 1.0)
+    elev        = kwargs.get('elev', 30)
+    azim        = kwargs.get('azim', -60)
+
+    todos_frames = [
+        np.array(historico[func_idx][f]).reshape(disc_n)
+        for f in range(0, len(historico[func_idx]), frames_step)
+    ]
+    z_min = min(Z.min() for Z in todos_frames)
+    z_max = max(Z.max() for Z in todos_frames)
+
+    fig = plt.figure(figsize=(8, 6))
+    ax  = fig.add_subplot(111, projection='3d')
+
+    def update(frame):
+        ax.clear()
+        Z = todos_frames[frame]
+        ax.plot_surface(X, Y, Z, cmap=cmap, alpha=alpha)
+        ax.set_title(
+            f"Evolução 3D de {funcs[func_idx]} - Passo {frame * frames_step}"
+        )
+        ax.set_xlabel('x')
+        ax.set_ylabel('y')
+        ax.set_zlabel(str(funcs[func_idx]))
+        ax.set_zlim(z_min, z_max)
+        ax.view_init(elev=elev, azim=azim)
+
+    anim = FuncAnimation(fig, update, frames=len(todos_frames),
+                         interval=interval, blit=False)
+    plt.show()

pdesolver-0.1.0/pdesolver/Auxs/__init__.py

@@ -0,0 +1,2 @@
+from .FuncAux import symbol_references, repl_symbol, d_dt
+from .Visualize import visualize