pdesolver 0.1.0__py3-none-any.whl

pdesolver/Disc/boundaries/__init__.py

@@ -0,0 +1,44 @@
+from .boundary_base import BoundaryCondition
+from .dirichlet import DirichletBC
+from .neumann import NeumannBC
+from .robin import RobinBC
+
+
+BOUNDARY_REGISTRY: dict[str, type[BoundaryCondition]] = {
+    "dirichlet": DirichletBC,
+    "neumann": NeumannBC,
+    "robin": RobinBC,
+}
+
+
+def get_boundary(
+    name: str,
+    bd_func: str,
+    alpha: str = "0",
+    beta: str = "1",
+    use_time_derivative: bool = True,
+) -> BoundaryCondition:
+
+    key = name.lower()
+    if key not in BOUNDARY_REGISTRY:
+        raise ValueError(
+            f"Tipo de contorno desconhecido: '{name}'. "
+            f"Disponíveis: {list(BOUNDARY_REGISTRY.keys())}"
+        )
+    cls = BOUNDARY_REGISTRY[key]
+
+    if key == "dirichlet":
+        return cls(bd_func, use_time_derivative=use_time_derivative)
+    if key == "robin":
+        return cls(bd_func, alpha=alpha, beta=beta)
+    return cls(bd_func)
+
+
+__all__ = [
+    "BoundaryCondition",
+    "DirichletBC",
+    "NeumannBC",
+    "RobinBC",
+    "BOUNDARY_REGISTRY",
+    "get_boundary",
+]

pdesolver/Disc/boundaries/boundary_base.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class BoundaryCondition(ABC):
+
+    def __init__(self, bd_func: str):
+        self.bd_func = bd_func
+
+    @abstractmethod
+    def apply(
+        self,
+        bd: str,
+        list_eq: List[List[str]],
+        n_part: List[int],
+        xd_var: List[str],
+        str_sp_vars: str = "",
+    ) -> List[List[str]]:
+
+        ...
+
+    @staticmethod
+    def _valid_sides_2d() -> List[str]:
+        return ["north", "south", "east", "west"]
+
+    @staticmethod
+    def _valid_sides_1d() -> List[str]:
+        return ["east", "west"]
+
+    def _check_side(self, bd: str, is_2d: bool) -> None:
+        valid = self._valid_sides_2d() if is_2d else self._valid_sides_1d()
+        if bd.lower() not in valid:
+            raise ValueError(
+                f"Contorno inválido: '{bd}'. Válidos para "
+                f"{'2D' if is_2d else '1D'}: {valid}"
+            )

pdesolver/Disc/boundaries/dirichlet.py

@@ -0,0 +1,83 @@
+
+from typing import List
+from ...Auxs.FuncAux import repl_symbol as _repl_symbol
+from .boundary_base import BoundaryCondition
+
+
+class DirichletBC(BoundaryCondition):
+
+    def __init__(self, bd_func: str, use_time_derivative: bool = True):
+        super().__init__(bd_func)
+        self.use_time_derivative = use_time_derivative
+
+    def _replace_xy(self, expr: str, X: str, Y: str, str_sp_vars: str) -> str:
+        out = _repl_symbol(expr, str_sp_vars[0], X)
+        if len(str_sp_vars) == 2:
+            out = _repl_symbol(out, str_sp_vars[1], Y)
+        return out
+
+    def apply(
+        self,
+        bd: str,
+        list_eq: List[List[str]],
+        n_part: List[int],
+        xd_var: List[str],
+        str_sp_vars: str = "",
+    ) -> List[List[str]]:
+
+        is_2d = len(str_sp_vars) == 2
+        self._check_side(bd, is_2d)
+        bd = bd.lower()
+
+        if is_2d:
+            return self._apply_2d(bd, list_eq, n_part, xd_var, str_sp_vars)
+        return self._apply_1d(bd, list_eq, n_part, xd_var, str_sp_vars)
+
+    def _apply_2d(self, bd, list_eq, n_part, xd_var, str_sp_vars):
+        Nx, Ny = n_part[0], n_part[1]
+        hx = f"h{xd_var[0]}_"
+        hy = f"h{xd_var[0]}_"
+        result = [[] for _ in range(len(list_eq))]
+
+        if bd == "north":
+            for func in range(len(list_eq)):
+                for i in range(Nx):
+                    expr = self._replace_xy(self.bd_func, f"{i} * {hx}", f"{Ny-1} * {hy}", str_sp_vars)
+                    result[func].append(expr)
+
+        elif bd == "south":
+            for func in range(len(list_eq)):
+                for i in range(Nx):
+                    expr = self._replace_xy(self.bd_func, f"{i} * {hx}", f"0 * {hy}", str_sp_vars)
+                    result[func].append(expr)
+
+        elif bd == "east":
+            for func in range(len(list_eq)):
+                for j in range(Ny):
+                    expr = self._replace_xy(self.bd_func, f"{Nx-1} * {hx}", f"{j} * {hy}", str_sp_vars)
+                    result[func].append(expr)
+
+        elif bd == "west":
+            for func in range(len(list_eq)):
+                for j in range(Ny):
+                    expr = self._replace_xy(self.bd_func, f"0 * {hx}", f"{j} * {hy}", str_sp_vars)
+                    result[func].append(expr)
+
+        return result
+
+    def _apply_1d(self, bd, list_eq, n_part, xd_var, str_sp_vars):
+        Nx = n_part[0]
+        hx = f"h{xd_var[0]}_"
+        result = [[] for _ in range(len(list_eq))]
+
+        if bd == "west":
+            for func in range(len(list_eq)):
+                expr = self._replace_xy(self.bd_func, f"0 * {hx}", "", str_sp_vars)
+                result[func].append(expr)
+
+        elif bd == "east":
+            for func in range(len(list_eq)):
+                expr = self._replace_xy(self.bd_func, f"{Nx-1} * {hx}", "", str_sp_vars)
+                result[func].append(expr)
+
+        return result

pdesolver/Disc/boundaries/neumann.py

@@ -0,0 +1,48 @@
+from typing import List
+from .boundary_base import BoundaryCondition
+
+class NeumannBC(BoundaryCondition):
+
+    def __init__(self, bd_func: str):
+        super().__init__(bd_func)
+
+    def apply(
+        self,
+        bd: str,
+        list_eq: List[List[str]],
+        n_part: List[int],
+        xd_var: List[str],
+        str_sp_vars: str = "",
+    ) -> List[List[str]]:
+
+        is_2d = len(str_sp_vars) == 2
+        self._check_side(bd, is_2d)
+        bd = bd.lower()
+
+        if is_2d:
+            return self._apply_2d(bd, list_eq, n_part, xd_var, str_sp_vars)
+        return self._apply_1d(bd, list_eq, n_part, xd_var, str_sp_vars)
+
+    def _apply_2d(self, bd, list_eq, n_part, xd_var, str_sp_vars):
+        Nx, Ny = n_part[0], n_part[1]
+        n_funcs = len(list_eq)
+        result = [[] for _ in range(n_funcs)]
+
+        if bd in ("west", "east"):
+            length = Ny
+        elif bd in ("south", "north"):
+            length = Nx
+        else:
+            raise ValueError(f"Lado invalido: {bd}")
+
+        for func in range(n_funcs):
+            for _ in range(length):
+                result[func].append("0")
+        return result
+
+    def _apply_1d(self, bd, list_eq, n_part, xd_var, str_sp_vars):
+        n_funcs = len(list_eq)
+        result = [[] for _ in range(n_funcs)]
+        for func in range(n_funcs):
+            result[func].append("0")
+        return result

pdesolver/Disc/boundaries/periodic_example.py

@@ -0,0 +1,30 @@
+from typing import List
+from .boundary_base import BoundaryCondition
+
+
+class PeriodicBC(BoundaryCondition):
+    def apply(
+        self,
+        bd: str,
+        list_eq: List[List[str]],
+        n_part: List[int],
+        xd_var: List[str],
+        str_sp_vars: str = "",
+    ) -> List[List[str]]:
+
+        is_2d = len(str_sp_vars) == 2
+        self._check_side(bd, is_2d)
+        bd = bd.lower()
+
+        result = [[] for _ in range(len(list_eq))]
+
+        if not is_2d:
+            for func in range(len(list_eq)):
+                if bd == "west":
+                    result[func].append(list_eq[func][-1])
+                elif bd == "east":
+                    result[func].append(list_eq[func][0])
+        else:
+            raise NotImplementedError("Periódico 2D ainda não implementado.")
+
+        return result

pdesolver/Disc/boundaries/robin.py

@@ -0,0 +1,51 @@
+from typing import List
+from .boundary_base import BoundaryCondition
+
+
+class RobinBC(BoundaryCondition):
+
+    def __init__(self, bd_func: str, alpha: str = "0", beta: str = "1"):
+        super().__init__(bd_func)
+        self.alpha = alpha
+        self.beta  = beta
+
+    def apply(
+        self,
+        bd: str,
+        list_eq: List[List[str]],
+        n_part: List[int],
+        xd_var: List[str],
+        str_sp_vars: str = "",
+    ) -> List[List[str]]:
+
+        is_2d = len(str_sp_vars) == 2
+        self._check_side(bd, is_2d)
+        bd = bd.lower()
+
+        if is_2d:
+            return self._apply_2d(bd, list_eq, n_part, xd_var, str_sp_vars)
+        return self._apply_1d(bd, list_eq, n_part, xd_var, str_sp_vars)
+
+    def _apply_2d(self, bd, list_eq, n_part, xd_var, str_sp_vars):
+        Nx, Ny = n_part[0], n_part[1]
+        n_funcs = len(list_eq)
+        result = [[] for _ in range(n_funcs)]
+
+        if bd in ("west", "east"):
+            length = Ny
+        elif bd in ("south", "north"):
+            length = Nx
+        else:
+            raise ValueError(f"Lado invalido: {bd}")
+
+        for func in range(n_funcs):
+            for _ in range(length):
+                result[func].append("0")
+        return result
+
+    def _apply_1d(self, bd, list_eq, n_part, xd_var, str_sp_vars):
+        n_funcs = len(list_eq)
+        result = [[] for _ in range(n_funcs)]
+        for func in range(n_funcs):
+            result[func].append("0")
+        return result

pdesolver/PDE.py

@@ -0,0 +1,29 @@
+class PDE:
+
+    eq = ''
+    func = ''
+    expr_ic = ''
+    sp_var = []
+    ivar = []
+    ivar_boundary = []
+    ic = []
+
+    def __init__(self, eq, func, sp_var, ivar, ivar_boundary, expr_ic,
+                 west_bd="Dirichlet", west_func_bd="0",
+                 east_bd="Dirichlet", east_func_bd="0",
+                 north_bd="Dirichlet", north_func_bd="0",
+                 south_bd="Dirichlet", south_func_bd="0"):
+        self.eq = eq
+        self.func = func
+        self.expr_ic = expr_ic
+        self.sp_var = sp_var
+        self.ivar = ivar
+        self.ivar_boundary = ivar_boundary
+        self.west_bd       = west_bd
+        self.west_func_bd  = west_func_bd
+        self.east_bd       = east_bd
+        self.east_func_bd  = east_func_bd
+        self.north_bd      = north_bd
+        self.north_func_bd = north_func_bd
+        self.south_bd      = south_bd
+        self.south_func_bd = south_func_bd

pdesolver/PDES.py

@@ -0,0 +1,175 @@
+from .Disc.Disc import df
+from .Solvers.CN import cn
+from .Solvers import RKF as SERKF45
+from .Solvers.bdf2 import bdf2
+from .Auxs.Visualize import visualize as _visualize
+import sympy as sp
+import numpy as np
+import matplotlib
+from .PDE import PDE
+import json
+from .Auxs.PDESEncoder import PDESEncoder
+
+
+class PDES:
+
+    @property
+    def disc_n(self):
+        return self._disc_n
+
+    @disc_n.setter
+    def disc_n(self, value):
+        self._disc_n = value
+        self.ic = self._ic_calc(self.pdes)
+        self.disc_results = None
+        self.dirichlet_constraints = {}
+        self.neumann_constraints   = {}
+
+
+    def __init__(self, pdes, disc_n, n_sp=1, n_temp=1):
+        self.pdes    = pdes
+        self.eqs     = [pde.eq   for pde in pdes]
+        self.ivars   = pdes[0].ivar
+        self.disc_results          = None
+        self.dirichlet_constraints = {}
+        self.neumann_constraints   = {}
+
+        self.funcs   = [pde.func for pde in pdes]
+        self.sp_vars = pdes[0].sp_var
+        self._disc_n  = disc_n
+        self.ic      = self._ic_calc(pdes)
+        self.results = None
+
+    def _ic_calc(self, pdes):
+        all_ics = []
+        for pde in pdes:
+            expr       = sp.parse_expr(pde.expr_ic)
+            sp_symbols = [sp.Symbol(v) for v in pde.sp_var]
+            grids      = []
+            for i in range(len(pde.sp_var)):
+                a, b = pde.ivar_boundary[i]
+                grids.append(np.linspace(a, b, self.disc_n[i]))
+            mesh      = np.meshgrid(*grids, indexing='ij')
+            f_ic      = sp.lambdify(sp_symbols, expr, modules='numpy')
+            ic_values = f_ic(*mesh)
+            if np.isscalar(ic_values):
+                ic_values = np.broadcast_to(ic_values, mesh[0].shape)
+            all_ics.extend(ic_values.flatten().tolist())
+        return all_ics
+
+    def xs(self, vars):
+        nvars = vars.copy()
+        for i in range(len(nvars)):
+            nvars[i] = f'XX{i}'
+        return nvars
+
+    def discretize(self, method='central'):
+        flat_list, d_vars, dirichlet_constraints, neumann_constraints = df(
+            self, self.disc_n,
+            method=method,
+            west_bd       = [pde.west_bd       for pde in self.pdes],
+            west_func_bd  = [pde.west_func_bd  for pde in self.pdes],
+            east_bd       = [pde.east_bd       for pde in self.pdes],
+            east_func_bd  = [pde.east_func_bd  for pde in self.pdes],
+            north_bd      = [pde.north_bd      for pde in self.pdes],
+            north_func_bd = [pde.north_func_bd for pde in self.pdes],
+            south_bd      = [pde.south_bd      for pde in self.pdes],
+            south_func_bd = [pde.south_func_bd for pde in self.pdes],
+        )
+        self.disc_results          = (flat_list, d_vars)
+        self.dirichlet_constraints = dirichlet_constraints
+        self.neumann_constraints   = neumann_constraints
+
+    def solve(self, method='bdf2', tf=1.0, nt=100, tol=1e-6, verbose=False, **kwargs):
+        dt = tf / nt
+        dc = self.dirichlet_constraints
+        nc = getattr(self, 'neumann_constraints', {})
+
+        if method == 'bdf2':
+            self.results = bdf2(
+                self.disc_results[0], self.disc_results[1],
+                tf=tf, nt=nt, ic=self.ic,
+                n_funcs=len(self.funcs),
+                dirichlet_constraints=dc,
+                neumann_constraints=nc,
+                verbose=verbose,
+                **kwargs
+            )
+        elif method == 'CN':
+            self.results = cn(
+                self.disc_results[0], self.disc_results[1],
+                tf=tf, nt=nt, ic=self.ic,
+                n_funcs=len(self.funcs),
+                dirichlet_constraints=dc,
+                neumann_constraints=nc,
+                verbose=verbose,
+                **kwargs
+            )
+        elif method == 'RKF':
+            self.results = SERKF45.SERKF45_cuda(
+                self.disc_results[0],
+                ivar=self.ivars,
+                funcs=self.disc_results[1],
+                yn=self.ic,
+                sp_vars=self.sp_vars,
+                n=100,
+                n_funcs=len(self.funcs),
+                dt_init=dt,
+                tol=tol,
+                x0=0,
+                xn=nt * dt,
+                dirichlet_constraints=dc,
+                neumann_constraints=nc,
+                verbose=verbose
+            )
+        else:
+            raise ValueError(
+                f"Metodo '{method}' desconhecido. Use: 'bdf2', 'CN' ou 'RKF'."
+            )
+        return self.results
+
+    def visualize(self, mode='heatmap', func_idx=0, time_step=-1, **kwargs):
+        _visualize(self, mode=mode, func_idx=func_idx,
+                   time_step=time_step, **kwargs)
+
+    def __repr__(self):
+        status = 'resolvido' if self.results is not None else 'nao resolvido'
+        return (f"PDES(funcs={self.funcs}, disc_n={self.disc_n}, "
+                f"sp_vars={self.sp_vars}, status='{status}')")
+
+    def save_to_json(self, filepath="pdes1.json"):
+        data = {
+            'disc_n': list(self.disc_n),
+            'pdes': [pde.__dict__ for pde in self.pdes],
+            'results': self.results,
+        }
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(data, f, cls=PDESEncoder, indent=4, ensure_ascii=False)
+        print(f"Objeto salvo com sucesso em: {filepath}")
+
+    @classmethod
+    def load_from_json(cls, filepath, pde_class=PDE):
+        import inspect
+        with open(filepath, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+
+        init_params = set(inspect.signature(pde_class.__init__).parameters) - {'self'}
+
+        reconstructed_pdes = []
+        for pde_dict in data['pdes']:
+            kwargs = {k: v for k, v in pde_dict.items() if k in init_params}
+            reconstructed_pdes.append(pde_class(**kwargs))
+
+        obj = cls(pdes=reconstructed_pdes, disc_n=data['disc_n'])
+        obj.disc_results = None
+        obj.dirichlet_constraints = {}
+        obj.neumann_constraints   = {}
+
+        if data.get('results') is not None:
+            raw = data['results']
+            try:
+                obj.results = np.array(raw)
+            except ValueError:
+                obj.results = np.array([np.array(r) for r in raw], dtype=object)
+
+        return obj

pdesolver/Solvers/CN.py

@@ -0,0 +1,151 @@
+from tabnanny import verbose
+import time
+import numpy as np
+import sympy as sp
+from sympy.parsing.sympy_parser import parse_expr
+import scipy.sparse as sp_sparse
+from scipy.sparse.linalg import spsolve
+
+from .solver_base import (
+    compile_equations, extract_linear_structure, detect_linearity,
+    eval_F, picard_step, newton_step,
+    make_history, save_to_history,
+)
+
+
+def _make_bc_lambda(expr_str: str):
+    t_sym, x_sym, y_sym = sp.symbols('t x y')
+    expr = parse_expr(expr_str)
+    return sp.lambdify((t_sym, x_sym, y_sym), expr, modules='numpy')
+
+
+def cn(flat_list, d_vars, tf, nt, ic, n_funcs=None,
+       nonlinear_method='newton', tol_nl=1e-8, max_iter_nl=20,
+       dirichlet_constraints=None,
+       neumann_constraints=None,
+       verbose=False):
+    dt = tf / nt
+    n  = len(d_vars)
+    u  = np.array(ic, dtype=np.float64).flatten()
+
+    dirichlet_constraints = dirichlet_constraints or {}
+    neumann_constraints   = neumann_constraints   or {}
+
+    dirichlet_lambdas = {
+        idx: _make_bc_lambda(info['expr'])
+        for idx, info in dirichlet_constraints.items()
+    }
+    neumann_lambdas = {
+        idx: _make_bc_lambda(info['expr'])
+        for idx, info in neumann_constraints.items()
+    }
+
+    h_neumann = None
+    if neumann_constraints:
+        all_x = set(); all_y = set()
+        for info in dirichlet_constraints.values():
+            all_x.add(round(info['x'], 12))
+            all_y.add(round(info['y'], 12))
+        for info in neumann_constraints.values():
+            all_x.add(round(info['x'], 12))
+            all_y.add(round(info['y'], 12))
+        Nx_est = len(all_x); Ny_est = len(all_y)
+        if Nx_est >= 2:
+            h_neumann = 1.0 / (Nx_est - 1)
+        elif Ny_est >= 2:
+            h_neumann = 1.0 / (Ny_est - 1)
+        else:
+            raise RuntimeError(
+                "Nao foi possivel inferir o passo h da malha para Neumann."
+            )
+
+    def _apply_dirichlet(u, t_val):
+        for idx, info in dirichlet_constraints.items():
+            f = dirichlet_lambdas[idx]
+            u[idx] = float(f(t_val, info['x'], info['y']))
+        return u
+
+    def _apply_neumann(u, t_val):
+        if h_neumann is None:
+            return u
+        two_h = 2.0 * h_neumann
+        for idx, info in neumann_constraints.items():
+            f = neumann_lambdas[idx]
+            f_val = float(f(t_val, info['x'], info['y']))
+            u[idx] = (4.0 * u[info['idx_n1']]
+                      - u[info['idx_n2']]
+                      + two_h * f_val) / 3.0
+        return u
+
+    def _apply_bcs(u, t_val):
+        u = _apply_dirichlet(u, t_val)
+        u = _apply_neumann(u, t_val)
+        return u
+
+    u = _apply_bcs(u, 0.0)
+
+    final_list, use_groups, n_elements = make_history(n_funcs, n)
+
+    funcs = compile_equations(flat_list, d_vars)
+
+    overwrite_indices = list(dirichlet_constraints.keys()) + list(neumann_constraints.keys())
+    is_linear, L = detect_linearity(funcs, n,
+                                    dirichlet_indices=overwrite_indices)
+
+    I = sp_sparse.eye(n, format='csr')
+
+    if is_linear:
+        _, fonte_func = extract_linear_structure(funcs, n, verbose=False)
+        A_impl = I - (dt / 2.0) * L
+        A_expl = I + (dt / 2.0) * L
+    else:
+        if verbose:
+            print(f"  [CN] EDP nao-linear detectada - usando {nonlinear_method.upper()} "
+                  f"(tol={tol_nl:.0e}, max_iter={max_iter_nl})")
+        _, fonte_func = extract_linear_structure(funcs, n, verbose=False)
+
+    save_to_history(u, final_list, use_groups, n_funcs, n_elements)
+
+    t0 = time.time()
+    total_iters = 0
+
+    for passo in range(nt):
+        tempo_atual   = passo * dt
+        tempo_proximo = (passo + 1) * dt
+
+        if is_linear:
+            f_n  = fonte_func(tempo_atual)
+            f_n1 = fonte_func(tempo_proximo)
+            rhs  = A_expl.dot(u) + (dt / 2.0) * (f_n + f_n1)
+            u    = spsolve(A_impl, rhs)
+            u    = _apply_bcs(u, tempo_proximo)
+
+        else:
+            F_n      = eval_F(funcs, tempo_atual, u)
+            rhs_hist = u + (dt / 2.0) * F_n
+
+            if nonlinear_method == 'newton':
+                u, n_iter = newton_step(
+                    funcs, u, tempo_proximo, dt, n, rhs_hist,
+                    alpha=0.5, max_iter=max_iter_nl,
+                    tol_nl=tol_nl, verbose=verbose
+                )
+            else:
+                u, n_iter = picard_step(
+                    funcs, u, tempo_proximo, dt, n, rhs_hist,
+                    alpha=0.5, max_iter=max_iter_nl,
+                    tol_nl=tol_nl, verbose=verbose
+                )
+            u = _apply_bcs(u, tempo_proximo)
+            total_iters += n_iter
+
+        save_to_history(u, final_list, use_groups, n_funcs, n_elements)
+
+    elapsed = time.time() - t0
+    if verbose:
+        print(f"  [CN] Loop de tempo: {elapsed:.3f}s", end="")
+        if not is_linear:
+            print(f" | Media iteracoes/passo: {total_iters/nt:.1f}", end="")
+        print()
+
+    return u, final_list