rbflab 0.1.0__py3-none-any.whl

rbflab/__init__.py

@@ -0,0 +1,70 @@
+"""RBFLAB: radial basis functions for interpolation and PDEs."""
+from .precision import Precision, PrecisionData
+from .kernels import IMQ, Gaussian, PHS, Hybrid, DivergenceFree
+from .operators import Identity, Derivative, Laplacian, NormalDerivative, Robin
+from .geometry import PointCloud, gmsh_square, gmsh_cube, unit_box_grid
+from .problems import LinearPDE, BoundaryCondition, Dirichlet
+from .nodal import rbf_fd_weights
+from .rbf_fd import RBFFD
+from .methods import GlobalCollocation, LHI, interpolate
+
+__all__ = [
+    "from_rbfmeshgen", "nodal_diagnostics", "TimeData", "UnsteadyStokesProblem", "LHIUnsteadyStokes", "GlobalUnsteadyStokes", "StokesProblem", "GlobalStokes", "StencilPolicy", "Precision", "PrecisionData", "IMQ", "Gaussian", "PHS", "Hybrid", "DivergenceFree", "Identity", "Derivative", "Laplacian",
+    "NormalDerivative", "Robin", "PointCloud", "gmsh_square", "gmsh_cube", "unit_box_grid", "LinearPDE",
+    "BoundaryCondition", "Dirichlet", "GlobalCollocation", "LHI", "RBFFD", "rbf_fd_weights", "interpolate",
+]
+
+
+from .stencils import StencilPolicy
+
+from .mesh_adapters import from_rbfmeshgen
+from .diagnostics import nodal_diagnostics
+
+from .stokes import StokesProblem, GlobalStokes
+
+from .unsteady_stokes import TimeData, UnsteadyStokesProblem, GlobalUnsteadyStokes
+
+from .lhi_stokes import LHIUnsteadyStokes
+
+from .strategies import growing_hybrid_stokes, growing_stencil_size
+__all__ += ["growing_hybrid_stokes", "growing_stencil_size"]
+
+from .evolution import EvolutionPDE, EvolutionSystem, EvolutionTrajectory
+__all__ += ["EvolutionPDE", "EvolutionSystem", "EvolutionTrajectory"]
+
+from .symbolic import SymbolicScalar
+__all__ += ["SymbolicScalar"]
+
+from .operators import SpatialOperator
+__all__ += ["SpatialOperator"]
+
+from .time_data import InitialData
+__all__ += ["InitialData"]
+
+from .symbolic_system import SymbolicSystem, BlockPDE
+from .block_methods import BlockGlobal, BlockLHI
+__all__ += ["SymbolicSystem", "BlockPDE", "BlockGlobal", "BlockLHI"]
+
+from .spaces import ScalarSpace, DivergenceFreeSpace, PressureSpace
+__all__ += ["ScalarSpace", "DivergenceFreeSpace", "PressureSpace"]
+
+from .legacy_cpp import LegacyCppLHIBackend
+__all__ += ["LegacyCppLHIBackend"]
+
+from .lhi_backends import PythonBackend, CppBackend
+__all__ += ['PythonBackend', 'CppBackend']
+
+from .symbolic_kernel import Kernel, Wendland
+__all__ += ["Kernel", "Wendland"]
+
+from .cuda_backend import CudaLHIBackend
+__all__ += ["CudaLHIBackend"]
+
+from .torch_backend import TorchBackend, TorchKernel
+__all__ += ['TorchBackend', 'TorchKernel']
+
+from .differentiable_lhi import DifferentiableLHI
+__all__ += ['DifferentiableLHI']
+
+from .discrete_operators import DiscreteOperator, OperatorSet
+__all__ += ["DiscreteOperator", "OperatorSet"]

rbflab/assembly.py

@@ -0,0 +1,73 @@
+"""Shared functional assembly and equilibrated dense solves."""
+import warnings
+import numpy as np
+from scipy.linalg import lu_factor, lu_solve, LinAlgWarning
+
+
+def functional_matrix(kernel, x, left, y, right):
+    from .operators import bind_operators
+    left, right = bind_operators(left,x), bind_operators(right,y)
+    out = np.empty((len(x), len(y)))
+    lg, rg = {}, {}
+    for i, op in enumerate(left):
+        lg.setdefault(op, []).append(i)
+    for i, op in enumerate(right):
+        rg.setdefault(op, []).append(i)
+    if len(lg)>8 or len(rg)>8:
+        # Point-dependent coefficients otherwise produce one tiny kernel call
+        # per point pair. Group derivative indices and multiply coefficient
+        # vectors outside the vectorized kernel blocks instead.
+        from .operators import Operator
+        out.fill(0)
+        terms=[]
+        for operators in (left,right):
+            groups={}
+            for i,op in enumerate(operators):
+                for alpha,c in op.terms:
+                    rows,coefficients=groups.setdefault(alpha,([],[]))
+                    rows.append(i);coefficients.append(float(c))
+            terms.append(groups)
+        for alpha,(rows,ca) in terms[0].items():
+            for beta,(cols,cb) in terms[1].items():
+                block=kernel.matrix(x[rows],y[cols],Operator(((alpha,1),)),Operator(((beta,1),)))
+                out[np.ix_(rows,cols)]+=np.asarray(ca)[:,None]*block*np.asarray(cb)[None,:]
+        return out
+    for opx, rows in lg.items():
+        for opy, cols in rg.items():
+            out[np.ix_(rows, cols)] = kernel.matrix(x[rows], y[cols], opx, opy)
+    return out
+
+
+class Factor:
+    """Diagonal equilibration; no jitter, pseudoinverse or silent regularization."""
+    def __init__(self, matrix, general=False, compute_condition=True):
+        self.matrix = np.asarray(matrix, dtype=float)
+        if self.matrix.ndim != 2 or self.matrix.shape[0] != self.matrix.shape[1] or not np.isfinite(self.matrix).all():
+            raise ValueError("Expected a finite square matrix")
+        diagonal = np.max(np.abs(self.matrix), axis=1) if general else np.abs(np.diag(self.matrix))
+        if np.any(diagonal == 0):
+            raise np.linalg.LinAlgError("Zero functional diagonal")
+        self.scale = 1 / np.sqrt(diagonal)
+        self.scaled = self.scale[:, None] * self.matrix * self.scale[None, :]
+        if type(compute_condition) is not bool:raise TypeError("compute_condition must be bool")
+        self.condition = float(np.linalg.cond(self.scaled)) if compute_condition else None
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", LinAlgWarning)
+            try:
+                self.lu = lu_factor(self.scaled)
+            except LinAlgWarning as exc:
+                raise np.linalg.LinAlgError(str(exc)) from exc
+        if self.condition is not None and (not np.isfinite(self.condition) or self.condition > 1e15):
+            warnings.warn(f"Ill-conditioned equilibrated system: {self.condition:.3e}",
+                          RuntimeWarning, stacklevel=2)
+
+    def solve(self, rhs, transpose=False):
+        rhs = np.asarray(rhs)
+        scale = self.scale if rhs.ndim == 1 else self.scale[:, None]
+        return scale * lu_solve(self.lu, scale * rhs, trans=1 if transpose else 0)
+
+
+def relative_residual(matrix, solution, rhs):
+    error = np.linalg.norm(matrix @ solution - rhs, ord=np.inf)
+    # RHS-relative residual: sensitive to inaccurate local/global solves.
+    return float(error / max(np.linalg.norm(rhs, ord=np.inf), np.finfo(float).tiny))

rbflab/block_methods.py

@@ -0,0 +1,292 @@
+"""Stationary block Hermite collocation and local Hermite assembly.
+
+Fields use independent scalar kernels. Differential coupling lives in explicit
+functional rows, including incompressibility; it is not built into the kernels.
+"""
+from .symbolic_kernel import BoundKernel
+import warnings
+from dataclasses import dataclass,field
+import numpy as np
+from scipy.spatial import cKDTree
+from .operators import Identity
+from .kernels import ScalarKernel, PHS, Hybrid
+from .nodal import Arithmetic,NodalBasis
+from .precision import Precision
+from .stencils import StencilPolicy
+from .symbolic_system import BlockPDE
+from .evolution import _sparse,_factor,_mv
+
+
+def _kernels(selection,problem):
+    if not isinstance(selection,dict):return [selection]*len(problem.fields)
+    resolved={}
+    for key,kernel in selection.items():
+        keys=key if isinstance(key,tuple) else (key,)
+        for item in keys:
+            index=problem.field_index(item)
+            if index in resolved:raise ValueError("Kernel assigned more than once to a field")
+            resolved[index]=kernel
+    if len(resolved)!=len(problem.fields):raise ValueError("Supply a kernel for every field")
+    return [resolved[i] for i in range(len(problem.fields))]
+
+
+def _arithmetic(kernels,digits):
+    if any(not isinstance(kernel,(ScalarKernel,PHS,Hybrid,BoundKernel)) for kernel in kernels):
+        raise TypeError("Block fields require scalar IMQ, Gaussian, PHS or Hybrid kernels")
+    arithmetics=[Arithmetic(kernel,digits) for kernel in kernels]
+    master=arithmetics[0]
+    if master.ctx:
+        for a in arithmetics[1:]:a.ctx=master.ctx;a.backend.ctx=master.ctx
+    return arithmetics
+
+
+def _validate(problem,cloud):
+    if not isinstance(problem,BlockPDE):raise TypeError("Expected a compiled BlockPDE")
+    if cloud.dimension!=problem.dimension:raise ValueError("Cloud and block problem dimensions must match")
+    if not len(cloud.interior):raise ValueError("Block PDEs require interior nodes")
+    for c in problem.constraints:
+        if not np.isfinite(np.asarray(c.point,dtype=float)).all():raise ValueError("Constraint points must be finite")
+
+
+def _boundary(problem,cloud,a):
+    result={}
+    for bc in problem.boundary:
+        labels=list(cloud.boundary) if bc.on=='boundary' else ([bc.on] if isinstance(bc.on,str) else list(bc.on))
+        for label in labels:
+            if label not in cloud.boundary:raise ValueError(f"Unknown boundary label: {label}")
+            ids=cloud.boundary[label];data=bc.rhs
+            if getattr(data,'requires_normals',False):
+                if label not in cloud.normals:raise ValueError(f"Normals required on {label}")
+                data=data.bind_normals(cloud.normals[label])
+            vals=a.data(data,cloud.points[ids])
+            for j,node in enumerate(ids):
+                key=(int(node),bc.slot)
+                if key in result:continue
+                normal=cloud.normals[label][j] if label in cloud.normals else None
+                ops={}
+                for f,op in bc.operators.items():
+                    if getattr(op,'requires_normals',False) and normal is None:raise ValueError(f"Normals required on {label}")
+                    ops[f]=op.at_point(cloud.points[node],normal)
+                if not any(op.terms for op in ops.values()):raise ValueError("Zero boundary functional")
+                result[key]=(ops,vals[j])
+    if {node for node,slot in result}!=set(cloud.boundary_indices):raise ValueError("Every boundary node needs a block boundary condition")
+    return result
+
+
+class BlockBasis:
+    """Hermite representers of block functionals plus a polynomial tail per field."""
+    def __init__(self,arithmetics,points,functionals,degree,scaling='physical'):
+        self.arithmetics=arithmetics;self.a=arithmetics[0]
+        self.points=np.asarray(points,dtype=float);self.functionals=functionals
+        self.n=len(points);self.bases=[];self.offsets=[];offset=self.n
+        for f,a in enumerate(arithmetics):
+            ids=[i for i,row in enumerate(functionals) if f in row]
+            if not ids:raise ValueError(f"Field {f} has no source functionals")
+            basis=NodalBasis(a,self.points[ids],degree,source_operators=[functionals[i][f] for i in ids],kernel_scaling=scaling)
+            self.bases.append((ids,basis));self.offsets.append(offset);offset+=len(basis.powers)
+        self.size=offset
+
+    def evaluation(self,points,functionals):
+        points=np.asarray(points,dtype=float);out=self.a.zeros(len(points),self.size)
+        for f,(sources,basis) in enumerate(self.bases):
+            targets=[i for i,row in enumerate(functionals) if f in row]
+            if not targets:continue
+            block=basis.evaluation(points[targets],[functionals[i][f] for i in targets])
+            cols=sources+list(range(self.offsets[f],self.offsets[f]+len(basis.powers)))
+            if self.a.ctx:
+                for i,row in enumerate(targets):
+                    for j,col in enumerate(cols):out[row,col]+=block[i,j]
+            else:out[np.ix_(targets,cols)]+=block
+        return out
+
+    def matrix(self):
+        out=self.a.zeros(self.size,self.size)
+        out[:self.n,:]=self.evaluation(self.points,self.functionals)
+        P=out[:self.n,self.n:]
+        if self.size>self.n:
+            # Check polynomial unisolvency before numerical factorization.
+            check=np.array(P.tolist() if self.a.ctx else P,dtype=float)
+            scale=np.max(abs(check),axis=0)
+            check=check/np.where(scale>0,scale,1)
+            if np.linalg.matrix_rank(check)<self.size-self.n:
+                raise np.linalg.LinAlgError("Block polynomial functionals are not unisolvent; increase the stencil or change the polynomial degree")
+            out[self.n:,:self.n]=P.T
+        return out
+
+    def padded(self,data):return self.a.vector(list(data)+[self.a.number(0)]*(self.size-self.n))
+
+
+@dataclass
+class BlockGlobal:
+    """Symmetric block Hermite collocation; one scalar kernel or a field mapping."""
+    kernels: object
+    polynomial_degree: int | None = None
+    precision: Precision = field(default_factory=Precision)
+
+    def assemble(self,problem,cloud):
+        _validate(problem,cloud)
+        if not isinstance(self.precision,Precision):raise TypeError("Expected Precision")
+        if self.precision.local_digits is not None or self.precision.global_dtype!='float64':raise ValueError("BlockGlobal uses global_digits")
+        kernels=_kernels(self.kernels,problem);arithmetics=_arithmetic(kernels,self.precision.global_digits);a=arithmetics[0]
+        points=[];ops=[];rhs=[]
+        for eq in problem.equations:
+            points.extend(cloud.interior);ops.extend([eq.operators]*len(cloud.interior));rhs.extend(a.data(eq.rhs,cloud.interior))
+        for (node,slot),(row,value) in _boundary(problem,cloud,a).items():
+            points.append(cloud.points[node]);ops.append(row);rhs.append(value)
+        for c in problem.constraints:
+            point=np.asarray(c.point,dtype=float)[None,:]
+            points.append(point[0]);ops.append({c.field:Identity(problem.dimension)});rhs.extend(a.data(c.value,point))
+        basis=BlockBasis(arithmetics,points,ops,self.polynomial_degree)
+        system=BlockGlobalSystem(problem,basis,basis.matrix(),basis.padded(rhs))
+        return system
+
+
+class BlockGlobalSystem:
+    def __init__(self,problem,basis,matrix,rhs):
+        self.problem,self.basis,self.matrix,self.rhs=problem,basis,matrix,rhs
+        self.arithmetic=basis.a;self.factor=None
+
+    def solve(self):
+        if self.factor is None:self.factor=self.arithmetic.factor(self.matrix)
+        z=self.factor.solve(self.rhs);a=self.arithmetic
+        diagnostics={'relative_residual':float(a.norm(_mv(self.matrix,z)-self.rhs)/(a.norm(self.rhs) or a.number(1))),
+                     'unknowns':len(z),'scaled_condition':self.factor.condition,'method':'block_global',
+                     'digits':a.ctx.dps if a.ctx else None}
+        return BlockSolution(self,z,diagnostics)
+
+
+@dataclass
+class BlockLHI:
+    """Experimental block LHI, interior values and local PDE/BC constraints.
+
+    A point gauge adds a bordered row and a compatibility multiplier in its
+    specified equation slot. Inspect constraint_multipliers in diagnostics.
+    """
+    kernels: object
+    stencil_size: int = 25
+    polynomial_degree: int | None = None
+    precision: Precision = field(default_factory=Precision)
+    stencil_policy: StencilPolicy = field(default_factory=StencilPolicy)
+
+    def assemble(self,problem,cloud):
+        _validate(problem,cloud)
+        if not isinstance(self.precision,Precision):raise TypeError("Expected Precision")
+        if self.precision.global_digits is not None:raise ValueError("BlockLHI uses local_digits and global_dtype")
+        if type(self.stencil_size) is not int or not 3<=self.stencil_size<=len(cloud.points):raise ValueError("Invalid stencil_size")
+        if not isinstance(self.stencil_policy,StencilPolicy):raise TypeError("Expected StencilPolicy")
+        kernels=_kernels(self.kernels,problem);arithmetics=_arithmetic(kernels,self.precision.local_digits)
+        local=arithmetics[0];a=local if self.precision.global_dtype=='mpmath' else Arithmetic(kernels[0])
+        bd=_boundary(problem,cloud,local);ni=len(cloud.interior);nf=len(problem.fields);nc=len(problem.constraints)
+        interior={int(node):i for i,node in enumerate(cloud.interior_indices)}
+        rhs_data=[local.data(eq.rhs,cloud.points) for eq in problem.equations]
+        size=nf*ni+nc;rows=[{} for _ in range(size)];rhs=[a.number(0)]*size
+        tree=cKDTree(cloud.points);stencils=[];identity=Identity(problem.dimension)
+        for center in cloud.interior_indices:
+            neighbors=self.stencil_policy.select(tree,cloud.points[center],self.stencil_size,self.polynomial_degree)
+            selected=set(int(j) for j in neighbors);sc=[int(j) for j in neighbors if int(j) in interior]
+            points=[];ops=[];unknowns=[];known=[]
+            for f in range(nf):
+                for node in sc:
+                    points.append(cloud.points[node]);ops.append({f:identity})
+                    unknowns.append(f*ni+interior[node]);known.append(local.number(0))
+            ns=len(unknowns)
+            for (node,slot),(row,value) in bd.items():
+                if node in selected:points.append(cloud.points[node]);ops.append(row);known.append(value)
+            for f,eq in enumerate(problem.equations):
+                for node in sc:
+                    if node!=center:
+                        points.append(cloud.points[node]);ops.append(eq.operators);known.append(rhs_data[f][node])
+            basis=BlockBasis(arithmetics,points,ops,self.polynomial_degree,self.stencil_policy.scaling)
+            factor=local.factor(basis.matrix())
+            q=basis.evaluation(np.repeat(cloud.points[[center]],nf,axis=0),[eq.operators for eq in problem.equations]).T
+            weights=factor.solve(q,transpose=True).T[:,:basis.n]
+            stencil=dict(basis=basis,factor=factor,unknowns=unknowns,known=known,ns=ns)
+            stencils.append(stencil)
+            for f in range(nf):
+                row=f*ni+interior[int(center)];rhs[row]=a.number(rhs_data[f][center])
+                for j,col in enumerate(unknowns):rows[row][col]=a.number(weights[f,j])
+                rhs[row]-=sum(a.number(weights[f,j])*a.number(known[j]) for j in range(ns,len(known)))
+        owners=cKDTree(cloud.interior)
+        for k,c in enumerate(problem.constraints):
+            point=np.asarray(c.point,dtype=float)[None,:];_,owner=owners.query(point[0]);s=stencils[int(owner)]
+            q=s['basis'].evaluation(point,[{c.field:identity}]).T
+            w=s['factor'].solve(q,transpose=True)
+            row=nf*ni+k
+            for j,col in enumerate(s['unknowns']):rows[row][col]=a.number(w[j,0])
+            rhs[row]=a.number(local.data(c.value,point)[0])-sum(a.number(w[j,0])*a.number(s['known'][j]) for j in range(s['ns'],len(s['known'])))
+            for i in range(ni):rows[c.equation*ni+i][row]=a.number(1)
+        return BlockLHISystem(problem,cloud,a,local,_sparse(rows,a),a.vector(rhs),stencils,owners,nf*ni)
+
+
+class BlockLHISystem:
+    def __init__(self,problem,cloud,a,local,matrix,rhs,stencils,tree,physical_unknowns):
+        self.problem,self.cloud,self.arithmetic,self.local=problem,cloud,a,local
+        self.matrix,self.rhs,self.stencils,self.tree=matrix,rhs,stencils,tree
+        self.physical_unknowns=physical_unknowns;self.factor=None
+
+    def solve(self):
+        a=self.arithmetic
+        if self.factor is None:self.factor=_factor(self.matrix,a)
+        condition=None
+        if not a.ctx and len(self.rhs)<=400:
+            condition=float(np.linalg.cond(self.matrix.toarray()))
+            if condition>1e12:
+                warnings.warn("Ill-conditioned mixed LHI system; a small algebraic residual does not establish a unique accurate field",RuntimeWarning,stacklevel=2)
+        z=self.factor.solve(self.rhs)
+        multipliers=[float(v) for v in z[self.physical_unknowns:]]
+        if any(abs(v)>1e-6*(1+float(a.norm(self.rhs))) for v in multipliers):
+            warnings.warn("Mixed LHI has non-negligible constraint multipliers: the original PDE rows are not satisfied exactly; inspect residuals",RuntimeWarning,stacklevel=2)
+        diagnostics={'experimental':True,'global_condition':condition,'relative_residual':float(a.norm(_mv(self.matrix,z)-self.rhs)/(a.norm(self.rhs) or a.number(1))),
+            'unknowns':len(z),'method':'block_lhi','local_digits':self.local.ctx.dps if self.local.ctx else None,
+            'global_digits':a.ctx.dps if a.ctx else None,
+            'constraint_multipliers':multipliers,
+            'max_local_condition':max(s['factor'].condition for s in self.stencils)}
+        return BlockSolution(self,z,diagnostics)
+
+
+class BlockSolution:
+    def __init__(self,system,unknowns,diagnostics):
+        self.system,self.unknowns,self.diagnostics=system,unknowns,diagnostics
+        if isinstance(system,BlockLHISystem):
+            self.a=system.local;self.coefficients=[]
+            for s in system.stencils:
+                data=[self.a.number(unknowns[j]) for j in s['unknowns']]+s['known'][s['ns']:]
+                self.coefficients.append(s['factor'].solve(s['basis'].padded(data)))
+        else:self.a=system.arithmetic
+
+    def _rows(self,points,functionals):
+        from .methods import _query
+        points=_query(points,self.system.problem.dimension)
+        if len(functionals)!=len(points):raise ValueError("One functional per query point required")
+        if isinstance(self.system,BlockGlobalSystem):
+            return _mv(self.system.basis.evaluation(points,functionals),self.unknowns)
+        result=self.a.vector([0]*len(points))
+        if not len(points):return result
+        _,owners=self.system.tree.query(points)
+        for owner in np.unique(owners):
+            ids=np.flatnonzero(owners==owner);s=self.system.stencils[int(owner)]
+            block=s['basis'].evaluation(points[ids],[functionals[int(i)] for i in ids])
+            values=_mv(block,self.coefficients[int(owner)])
+            for j,i in enumerate(ids):result[int(i)]=values[j]
+        return result
+
+    def evaluate(self,points,*,field=None,operator=None,extended=False):
+        from .methods import _query
+        points=_query(points,self.system.problem.dimension)
+        if extended and not self.a.ctx:raise ValueError("Extended evaluation requires extended arithmetic")
+        p=self.system.problem;fields=range(len(p.fields)) if field is None else [p.field_index(field)]
+        op=operator or Identity(p.dimension);out=self.a.zeros(len(points),len(fields))
+        for j,f in enumerate(fields):
+            values=self._rows(points,[{f:op}]*len(points))
+            for i,v in enumerate(values):out[i,j]=v
+        if extended:return out
+        result=np.asarray(out.tolist() if self.a.ctx else out,dtype=float).reshape(len(points),len(fields))
+        return result[:,0] if field is not None else result
+
+    def residuals(self,points,*,extended=False):
+        if extended and not self.a.ctx:raise ValueError("Extended evaluation requires extended arithmetic")
+        p=self.system.problem;out=self.a.zeros(len(points),len(p.equations))
+        for j,eq in enumerate(p.equations):
+            vals=self._rows(points,[eq.operators]*len(points));rhs=self.a.data(eq.rhs,points)
+            for i,v in enumerate(vals):out[i,j]=v-rhs[i]
+        return out if extended else np.asarray(out.tolist() if self.a.ctx else out,dtype=float)

rbflab/cuda_backend.py

@@ -0,0 +1,85 @@
+"""Experimental CUDA Float64 local Stokes weights; global solve stays on CPU."""
+from dataclasses import dataclass
+from pathlib import Path
+from functools import lru_cache
+import hashlib,json,os,re,subprocess,tempfile,time
+import numpy as np
+from .kernel_compiler import as_bound,stokes_header,ROOT
+from .legacy_cpp import _linux_path
+from .lhi_backends import _prepare,_finish
+
+@lru_cache(maxsize=1)
+def cuda_toolchain():
+    prefix=['wsl.exe','-d','Ubuntu','--'] if os.name=='nt' else []
+    nvcc=subprocess.check_output(prefix+['nvcc','--version'],text=True)
+    capability=subprocess.check_output(prefix+['nvidia-smi','--query-gpu=compute_cap','--format=csv,noheader'],text=True).splitlines()[0].strip().replace('.','')
+    if not capability.isdigit():raise RuntimeError('Cannot determine CUDA architecture')
+    return prefix,nvcc,capability
+
+
+def compile_cuda(velocity,pressure,cache_dir=None):
+    prefix,nvcc,arch=cuda_toolchain();v,p=as_bound(velocity),as_bound(pressure)
+    dependencies=[ROOT/'cpp/cuda_lhi.cu',Path(__file__),Path(__file__).with_name('kernel_compiler.py'),Path(__file__).with_name('symbolic_kernel.py')]
+    identity=dict(velocity=repr(v.family),pressure=repr(p.family),nvcc=nvcc,arch=arch,flags=['-O3','--fmad=false','-ccbin=g++-12'],sources={str(x.name):hashlib.sha256(x.read_bytes()).hexdigest() for x in dependencies})
+    key=hashlib.sha256(json.dumps(identity,sort_keys=True).encode()).hexdigest();root=Path(cache_dir) if cache_dir else Path.home()/'.cache/rbflab/cuda';folder=root/key
+    manifest=folder/'manifest.json'
+    if manifest.is_file():
+        stored=json.loads(manifest.read_text())
+        if not all((folder/n).is_file() and hashlib.sha256((folder/n).read_bytes()).hexdigest()==h for n,h in stored['files'].items()):raise RuntimeError('CUDA cache integrity failure')
+        return folder/'cuda_lhi'
+    if folder.exists():raise RuntimeError('Incomplete CUDA cache; select a fresh cache directory')
+    code=stokes_header(v.family,p.family)
+    code=re.sub(r'Real\("([^"\n]+)"\)',lambda m:'('+m.group(1)+'.0)' if re.fullmatch(r'-?\d+',m.group(1)) else '('+m.group(1)+')',code)
+    code=code.replace('std::vector<Real> params','const double* params').replace('const std::vector<Real>& params','const double* params')
+    code=re.sub(r'params.at\((\d+)\)',r'params[\1]',code).replace('Real','double').replace('inline double','__device__ inline double')
+    code=re.sub(r'throw std::runtime_error\("[^"\n]+"\);','return nan("");',code)
+    source=(ROOT/'cpp/cuda_lhi.cu').read_text().replace('// RBFLAB_GENERATED_SPACE',code)
+    root.mkdir(parents=True,exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix='build-',dir=root) as tmp:
+        temp=Path(tmp);(temp/'kernel.cu').write_text(source)
+        path=_linux_path(temp)
+        result=subprocess.run(prefix+['nvcc','-O3','-std=c++17','--fmad=false','-ccbin','g++-12','-arch=sm_'+arch,path+'/kernel.cu','-lcublas','-o',path+'/cuda_lhi'],capture_output=True,text=True,timeout=300)
+        if result.returncode:raise RuntimeError('CUDA compile failed: '+result.stderr)
+        files={n:hashlib.sha256((temp/n).read_bytes()).hexdigest() for n in ('kernel.cu','cuda_lhi')}
+        (temp/'manifest.json').write_text(json.dumps(dict(identity=identity,files=files),indent=2));temp.rename(folder)
+    return folder/'cuda_lhi'
+
+@dataclass(frozen=True)
+class CudaLHIBackend:
+    """Feasibility backend: 2D, physical, unaugmented, Float64; no condition estimate."""
+    batch_size: int = 256
+    shape_rule: str = 'fixed'
+    cache_dir: str | None = None
+    timeout: float = 300
+    def __post_init__(self):
+        if type(self.batch_size) is not int or not 1<=self.batch_size<=4096:raise ValueError('batch_size must be 1..4096')
+        if self.shape_rule not in ('fixed','legacy_hardy'):raise ValueError('Unknown shape rule')
+    def assemble(self,method,problem,cloud):
+        begin=time.perf_counter()
+        if method.precision.local_digits is not None or method.precision.global_dtype!='float64':raise ValueError('CUDA prototype requires Float64 local/global arithmetic')
+        if cloud.dimension!=2 or method.stencil_policy.scaling!='physical' or method.polynomial_degree is not None:raise NotImplementedError('CUDA prototype requires unaugmented physical-coordinate 2D stencils')
+        pk=method.pressure_kernel or method.kernel
+        start=time.perf_counter();executable=compile_cuda(method.kernel,pk,self.cache_dir);compile_seconds=time.perf_counter()-start
+        a,tasks,stencils=_prepare(method,problem,cloud,self.shape_rule)
+        nv=len(as_bound(method.kernel).values);np_=len(as_bound(pk).values)
+        num=lambda v:format(float(v),'.17g')
+        lines=[f'{len(tasks)} {self.batch_size} {nv} {np_}']
+        for task in tasks:
+            lines.append(' '.join([str(len(task['points'])),num(task['mu']),*(num(v) for v in task['origin']),*(num(v) for v in as_bound(task['vk']).values),*(num(v) for v in as_bound(task['pk']).values)]))
+            lines.extend(' '.join([str(code),*(num(v) for v in point)]) for code,point in zip(task['codes'],task['points']))
+        with tempfile.TemporaryDirectory(prefix='rbflab_cuda_') as tmp:
+            folder=Path(tmp);source=folder/'input';target=folder/'output';source.write_text('\n'.join(lines)+'\n')
+            start=time.perf_counter();prefix=cuda_toolchain()[0]
+            runtime_prefix=prefix+['env','LD_LIBRARY_PATH=/usr/lib/wsl/lib'] if os.name=='nt' else prefix
+            result=subprocess.run([*runtime_prefix,_linux_path(executable),_linux_path(source),_linux_path(target)],capture_output=True,text=True,timeout=self.timeout);process=time.perf_counter()-start
+            if result.returncode:raise RuntimeError('CUDA local backend: '+result.stderr)
+            gpu=json.loads(result.stdout);results=[]
+            for i,line in enumerate(target.read_text().splitlines()):
+                items=line.split();n=len(tasks[i]['points'])
+                if int(items[0])!=i or int(items[1])!=n or len(items)!=4+4*n:raise RuntimeError('Invalid CUDA weight output')
+                if not all(np.isfinite(float(v)) for v in items[3:]):raise RuntimeError('Nonfinite CUDA output')
+                results.append(dict(condition=None,residual=items[3],weights=[items[4+k*n:4+(k+1)*n] for k in range(4)]))
+            if len(results)!=len(tasks):raise RuntimeError('Incomplete CUDA result')
+        system=_finish(method,problem,cloud,a,tasks,stencils,results,dict(backend='cuda_float64',compile_seconds=compile_seconds,cuda_process_seconds=process,gpu=gpu,batch_size=self.batch_size,local_digits=None,compute_condition=False,off_node_backend='lazy Python',shape_rule=self.shape_rule))
+        system.backend_diagnostics['assembly_seconds']=time.perf_counter()-begin
+        return system

rbflab/descriptor.py

@@ -0,0 +1,36 @@
+"""Small Float64 index-one descriptor spectrum diagnostic.
+
+For M udot + A u=0, left-null(M) gives algebraic constraints C u=0.
+Restrict u to null(C), project onto range(M), then solve the reduced pencil.
+Rank thresholds make this a numerical diagnostic, not a formal DAE certificate.
+"""
+import numpy as np
+from scipy.linalg import eig,svd,null_space
+
+
+def descriptor_spectrum(stiffness,mass,rtol=None):
+    a,m=np.asarray(stiffness),np.asarray(mass);n=len(m)
+    rtol=rtol or 100*n*np.finfo(float).eps
+    u,s,vh=svd(m);rank=int(np.sum(s>rtol*s[0])) if s[0]>0 else 0
+    info={'mass_rank':rank,'algebraic_modes':n-rank,'rank_relative_tolerance':rtol}
+    if rank==0:
+        if np.linalg.matrix_rank(a)<n:raise ValueError('Pure algebraic constraints are rank deficient')
+        return np.array([],dtype=complex),dict(info,eigenpair_relative_residual_max=None)
+    if rank==n:
+        values,vectors=eig(-a,m)
+    else:
+        constraints=u[:,rank:].T@a
+        z=null_space(constraints,rcond=rtol)
+        if z.shape[1]!=rank:
+            raise ValueError('Descriptor constraints are rank deficient; finite spectrum unresolved')
+        reduced_m=u[:,:rank].T@m@z;reduced_a=u[:,:rank].T@a@z
+        if np.linalg.matrix_rank(reduced_m,tol=rtol*np.linalg.norm(reduced_m,2))<rank:
+            raise ValueError('Descriptor has a singular reduced mass; higher-index spectrum unresolved')
+        values,w=eig(-reduced_a,reduced_m);vectors=z@w
+    residual=[]
+    norm_a,norm_m=np.linalg.norm(a,2),np.linalg.norm(m,2)
+    for value,vector in zip(values,vectors.T):
+        if not np.isfinite(value):continue
+        residual.append(float(np.linalg.norm(-a@vector-value*(m@vector))/(norm_a+abs(value)*norm_m)/np.linalg.norm(vector)))
+    info['eigenpair_relative_residual_max']=max(residual,default=None)
+    return values,info

rbflab/diagnostics.py

@@ -0,0 +1,56 @@
+"""Discrete nodal consistency and small-system stability diagnostics."""
+import numpy as np
+
+
+def nodal_diagnostics(system, exact_unknowns, *, condition_limit=200):
+    """Diagnose an assembled LHI/RBF-FD system, before reconstruction.
+
+    Pass exact values in matrix-column order: interior values for LHI, all
+    values for RBF-FD. This API does not accept global RBF coefficients.
+    Row normalization removes equation magnitude, not physical units.
+    A fixed alternating perturbation of the row-normalized RHS measures one
+    response direction, not worst-case amplification. The system is factored
+    lazily if necessary. Float64 small systems additionally report the row-scaled infinity-norm
+    condition; extended systems keep consistency arithmetic extended and omit
+    that Float64 condition estimate. No claim of a stability certificate.
+    """
+    matrix=system.matrix
+    if hasattr(matrix,"matvec"):
+        ctx=matrix.ctx
+        from .precision import mp_number
+        exact=ctx.matrix([mp_number(ctx,v) for v in exact_unknowns])
+        if any(not ctx.isfinite(v) for v in exact):
+            raise ValueError("Exact values must be finite")
+        if len(exact)!=len(system.rhs):
+            raise ValueError("Expected one exact value per unknown")
+        defect=matrix.matvec(exact)-system.rhs
+        norm=lambda x:ctx.norm(x,"inf")
+        scales=[max((abs(v) for v in row.values()),default=ctx.zero) for row in matrix.rows]
+        if any(v==0 for v in scales):
+            raise ValueError("Cannot normalize an empty equation")
+        from .sparse_precision import MPSparseLU
+        factor=system.factor or MPSparseLU(matrix)
+        response=factor.solve(ctx.matrix([scale*(-1)**i for i,scale in enumerate(scales)]))
+        normalized=ctx.matrix([defect[i]/scale for i,scale in enumerate(scales)])
+        return {"consistency_inf":float(norm(defect)),
+                "row_scaled_consistency_inf":float(norm(normalized)),
+                "consistency_decimal":ctx.nstr(norm(defect),16),
+                "digits":ctx.dps,"row_scaled_condition_inf":None,
+                "alternating_rhs_gain_inf":float(norm(response))}
+    exact=np.asarray(exact_unknowns,dtype=float)
+    if exact.shape!=(matrix.shape[1],) or not np.isfinite(exact).all():
+        raise ValueError("Expected one finite exact value per unknown")
+    defect=matrix@exact-system.rhs
+    scales=np.asarray(abs(matrix).max(axis=1).toarray()).ravel()
+    if np.any(scales==0):
+        raise ValueError("Cannot normalize an empty equation")
+    from scipy.sparse.linalg import splu
+    factor=system.factor or splu(matrix)
+    response=factor.solve(scales*(-1.)**np.arange(len(scales)))
+    condition=None
+    if matrix.shape[0]<=condition_limit:
+        condition=float(np.linalg.cond(matrix.toarray()/scales[:,None],np.inf))
+    return {"consistency_inf":float(np.max(abs(defect))),
+            "row_scaled_consistency_inf":float(np.max(abs(defect)/scales)),
+            "digits":None,"row_scaled_condition_inf":condition,
+            "alternating_rhs_gain_inf":float(np.max(abs(response)))}