fluxfem 0.1.4__py3-none-any.whl → 0.2.1__py3-none-any.whl

fluxfem/physics/elasticity/linear.py

@@ -1,10 +1,14 @@
+from typing import TypeAlias
+
 import jax.numpy as jnp
 
-from ...core.assembly import assemble_linear_form
+from ...core.assembly import LinearReturn
 from ...core.forms import FormContext, vector_load_form
-from ...core.basis import build_B_matrices
+from ...core.space import FESpace
 from ...physics.operators import sym_grad
 
+ArrayLike: TypeAlias = jnp.ndarray
+
 # from ...mechanics.kinematics import build_B_matrices
 
 
@@ -26,21 +30,35 @@ def linear_elasticity_form(ctx: FormContext, D: jnp.ndarray) -> jnp.ndarray:
     symmetric-gradient operator for the test/trial fields.
     """
     Bu = sym_grad(ctx.trial)                 # (n_q, 6, ndofs_e)
-    Bv = sym_grad(ctx.test)                  # (n_q, 6, ndofs_e)
+    Bv = Bu if ctx.test is ctx.trial else sym_grad(ctx.test)
     return jnp.einsum("qik,kl,qlm->qim", jnp.swapaxes(Bv, 1, 2), D, Bu)
 
 
+linear_elasticity_form._ff_kind = "bilinear"
+linear_elasticity_form._ff_domain = "volume"
+
+
 def vector_body_force_form(ctx: FormContext, load_vec: jnp.ndarray) -> jnp.ndarray:
     """Linear form for 3D vector body force f (constant in space)."""
     return vector_load_form(ctx.test, load_vec)
 
 
-def assemble_constant_body_force(space, gravity_vec, density: float, *, sparse: bool = False):
+vector_body_force_form._ff_kind = "linear"
+vector_body_force_form._ff_domain = "volume"
+
+def assemble_constant_body_force(
+    space: FESpace,
+    gravity_vec: ArrayLike,
+    density: float,
+    *,
+    sparse: bool = False,
+) -> LinearReturn:
     """
     Convenience: assemble body force from density * gravity vector.
     gravity_vec: length-3 array-like (direction and magnitude of g)
     density: scalar density (consistent with unit system)
     """
+    from ...core.assembly import assemble_linear_form
     g = jnp.asarray(gravity_vec)
     f_vec = density * g
     return assemble_linear_form(space, vector_body_force_form, params=f_vec, sparse=sparse)

fluxfem/physics/elasticity/stress.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
 
+from typing import TypeAlias
+
 import jax.numpy as jnp
 
+ArrayLike: TypeAlias = jnp.ndarray
+
 
-def _sym(A: jnp.ndarray) -> jnp.ndarray:
+def _sym(A: ArrayLike) -> ArrayLike:
     return 0.5 * (A + jnp.swapaxes(A, -1, -2))
 
 
-def principal_stresses(S: jnp.ndarray) -> jnp.ndarray:
+def principal_stresses(S: ArrayLike) -> ArrayLike:
     """
     Return principal stresses (eigvals) for symmetric 3x3 stress tensor.
     Supports batching over leading dimensions.
@@ -16,12 +20,12 @@ def principal_stresses(S: jnp.ndarray) -> jnp.ndarray:
     return jnp.linalg.eigvalsh(S_sym)
 
 
-def principal_sum(S: jnp.ndarray) -> jnp.ndarray:
+def principal_sum(S: ArrayLike) -> ArrayLike:
     """Sum of principal stresses (trace)."""
     return jnp.trace(S, axis1=-2, axis2=-1)
 
 
-def max_shear_stress(S: jnp.ndarray) -> jnp.ndarray:
+def max_shear_stress(S: ArrayLike) -> ArrayLike:
     """
     Maximum shear stress = (sigma_max - sigma_min) / 2.
     """
@@ -29,7 +33,7 @@ def max_shear_stress(S: jnp.ndarray) -> jnp.ndarray:
     return 0.5 * (vals[..., -1] - vals[..., 0])
 
 
-def von_mises_stress(S: jnp.ndarray) -> jnp.ndarray:
+def von_mises_stress(S: ArrayLike) -> ArrayLike:
     """
     von Mises equivalent stress: sqrt(3/2 * dev(S):dev(S)).
     """

fluxfem/physics/operators.py

@@ -2,11 +2,18 @@
 
 # fluxfem/mechanics/operators.py
 from __future__ import annotations
+
+from typing import Any, TypeAlias
+
 import jax
 import jax.numpy as jnp
 
+from ..core.context_types import FormFieldLike
+
+ArrayLike: TypeAlias = jnp.ndarray
+
 
-def dot(a, b):
+def dot(a: FormFieldLike | ArrayLike, b: ArrayLike) -> ArrayLike:
     """
     Batched matrix product on the last two axes.
 
@@ -19,7 +26,7 @@ def dot(a, b):
     return jnp.matmul(a, b)
 
 
-def ddot(a, b, c=None):
+def ddot(a: ArrayLike, b: ArrayLike, c: ArrayLike | None = None) -> ArrayLike:
     """
     Double contraction on the last two axes.
 
@@ -32,12 +39,12 @@ def ddot(a, b, c=None):
     return jnp.einsum("...ik,kl,...lm->...im", a_t, b, c)
 
 
-def transpose_last2(a):
+def transpose_last2(a: ArrayLike) -> ArrayLike:
     """Swap the last two axes (batched transpose)."""
     return jnp.swapaxes(a, -1, -2)
 
 
-def sym_grad(field) -> jnp.ndarray:
+def sym_grad(field: FormFieldLike) -> jnp.ndarray:
     """
     Symmetric gradient operator for vector mechanics (small strain).
 
@@ -89,7 +96,7 @@ def sym_grad(field) -> jnp.ndarray:
     return jax.vmap(B_single)(gradN)
 
 
-def sym_grad_u(field, u_elem: jnp.ndarray) -> jnp.ndarray:
+def sym_grad_u(field: FormFieldLike, u_elem: jnp.ndarray) -> jnp.ndarray:
     """
     Apply sym_grad(field) to a local displacement vector.
 

fluxfem/physics/postprocess.py

@@ -1,15 +1,33 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING, TypeAlias
+
 import numpy as np
 import jax
 import jax.numpy as jnp
 
 # from ..core.assembly import build_form_contexts
 from ..tools.visualizer import write_vtu
+from ..mesh import BaseMesh
+from ..core.space import FESpace
 from ..core.interp import interpolate_field_at_element_points
 
+if TYPE_CHECKING:
+    from jax import Array as JaxArray
+
+    ArrayLike: TypeAlias = np.ndarray | JaxArray
+else:
+    ArrayLike: TypeAlias = np.ndarray
+
 
-def make_point_data_displacement(mesh, space, u, *, compute_j: bool = True, deformed_scale: float = 1.0):
+def make_point_data_displacement(
+    mesh: BaseMesh,
+    space: FESpace,
+    u: ArrayLike,
+    *,
+    compute_j: bool = True,
+    deformed_scale: float = 1.0,
+) -> dict[str, np.ndarray]:
     """
     Common postprocess helper to build point data dictionaries:
       - displacement
@@ -58,14 +76,22 @@ def make_point_data_displacement(mesh, space, u, *, compute_j: bool = True, defo
     return point_data
 
 
-def write_point_data_vtu(mesh, space, u, filepath: str, *, compute_j: bool = True, deformed_scale: float = 1.0):
+def write_point_data_vtu(
+    mesh: BaseMesh,
+    space: FESpace,
+    u: ArrayLike,
+    filepath: str,
+    *,
+    compute_j: bool = True,
+    deformed_scale: float = 1.0,
+) -> None:
     """Write VTU with displacement/deformed_coords and optional J."""
     pdata = make_point_data_displacement(mesh, space, u, compute_j=compute_j, deformed_scale=deformed_scale)
     write_vtu(mesh, filepath, point_data=pdata)
 
 
 __all__ = ["make_point_data_displacement", "write_point_data_vtu", "interpolate_at_points"]
-def interpolate_at_points(space, u, points: np.ndarray):
+def interpolate_at_points(space: FESpace, u: ArrayLike, points: np.ndarray) -> np.ndarray:
     """
     Interpolate displacement field at given physical points (Hex8 only, structured search).
     - points: (m,3) array of physical coordinates.

fluxfem/solver/__init__.py

@@ -1,14 +1,33 @@
-from .sparse import SparsityPattern, FluxSparseMatrix
+from .sparse import (
+    SparsityPattern,
+    FluxSparseMatrix,
+    coalesce_coo,
+    concat_flux,
+    block_diag_flux,
+)
 from .dirichlet import (
+    DirichletBC,
     enforce_dirichlet_dense,
+    enforce_dirichlet_dense_jax,
+    enforce_dirichlet_fluxsparse,
     enforce_dirichlet_sparse,
     free_dofs,
+    split_dirichlet_matrix,
+    restrict_flux_to_free,
+    condense_dirichlet_system,
+    enforce_dirichlet_system,
     condense_dirichlet_fluxsparse,
+    condense_dirichlet_fluxsparse_coo,
     condense_dirichlet_dense,
     expand_dirichlet_solution,
 )
-from .cg import cg_solve, cg_solve_jax
+from .cg import cg_solve, cg_solve_jax, build_cg_operator, CGOperator
+from .preconditioner import make_block_jacobi_preconditioner
+from .block_system import build_block_system, split_block_matrix, BlockSystem
+from .block_matrix import FluxBlockMatrix, diag as block_diag, make as make_block_matrix
 from .newton import newton_solve
+from .result import SolverResult
+from .history import NewtonIterRecord
 from .solve_runner import (
     NonlinearAnalysis,
     NewtonLoopConfig,
@@ -21,19 +40,42 @@ from .solve_runner import (
     LinearSolveRunner,
 )
 from .solver import LinearSolver, NonlinearSolver
+from .petsc import petsc_solve, petsc_shell_solve, petsc_is_available
 
 __all__ = [
     "SparsityPattern",
     "FluxSparseMatrix",
+    "coalesce_coo",
+    "concat_flux",
+    "block_diag_flux",
+    "DirichletBC",
     "enforce_dirichlet_dense",
+    "enforce_dirichlet_dense_jax",
+    "enforce_dirichlet_fluxsparse",
     "enforce_dirichlet_sparse",
+    "split_dirichlet_matrix",
+    "enforce_dirichlet_system",
     "free_dofs",
+    "restrict_flux_to_free",
+    "condense_dirichlet_system",
     "condense_dirichlet_fluxsparse",
+    "condense_dirichlet_fluxsparse_coo",
     "condense_dirichlet_dense",
     "expand_dirichlet_solution",
     "cg_solve",
     "cg_solve_jax",
+    "build_cg_operator",
+    "CGOperator",
+    "make_block_jacobi_preconditioner",
+    "build_block_system",
+    "split_block_matrix",
+    "BlockSystem",
+    "FluxBlockMatrix",
+    "block_diag",
+    "make_block_matrix",
     "newton_solve",
+    "SolverResult",
+    "NewtonIterRecord",
     "LinearAnalysis",
     "LinearSolveConfig",
     "LinearStepResult",
@@ -44,4 +86,7 @@ __all__ = [
     "solve_nonlinear",
     "LinearSolver",
     "NonlinearSolver",
+    "petsc_solve",
+    "petsc_shell_solve",
+    "petsc_is_available",
 ]

fluxfem/solver/bc.py

@@ -107,6 +107,10 @@ def vector_surface_load_form(ctx: SurfaceFormContext, load: npt.ArrayLike) -> np
     return np.asarray(vector_load_form(ctx.v, load_arr))
 
 
+vector_surface_load_form._ff_kind = "linear"
+vector_surface_load_form._ff_domain = "surface"
+
+
 def make_vector_surface_load_form(load_fn):
     """
     Build a vector surface load form from a callable f(x_q) -> (n_q, dim).
@@ -115,9 +119,32 @@ def make_vector_surface_load_form(load_fn):
         load_q = load_fn(ctx.x_q)
         return vector_surface_load_form(ctx, load_q)
 
+    _form._ff_kind = "linear"
+    _form._ff_domain = "surface"
     return _form
 
 
+def traction_vector(traction, traction_dir: str) -> np.ndarray:
+    """
+    Resolve traction magnitude and direction string into a vector.
+    """
+    dir_map = {
+        "x": (1.0, 0.0, 0.0),
+        "xpos": (1.0, 0.0, 0.0),
+        "xneg": (-1.0, 0.0, 0.0),
+        "y": (0.0, 1.0, 0.0),
+        "ypos": (0.0, 1.0, 0.0),
+        "yneg": (0.0, -1.0, 0.0),
+        "z": (0.0, 0.0, 1.0),
+        "zpos": (0.0, 0.0, 1.0),
+        "zneg": (0.0, 0.0, -1.0),
+    }
+    key = traction_dir.strip().lower()
+    if key not in dir_map:
+        raise ValueError("TRACTION_DIR must be one of x/xpos/xneg/y/ypos/yneg/z/zpos/zneg")
+    return float(traction) * np.asarray(dir_map[key], dtype=float)
+
+
 def _surface_quadrature(node_coords: np.ndarray):
     m = node_coords.shape[0]
     if m == 4:
@@ -404,8 +431,17 @@ def facet_normals(surface: SurfaceMesh, *, outward_from: npt.ArrayLike | None =
     for i, facet in enumerate(facets):
         if len(facet) < 3:
             continue
-        p0, p1, p2 = coords[facet[0]], coords[facet[1]], coords[facet[2]]
-        n = np.cross(p1 - p0, p2 - p0)
+        n = None
+        p0 = coords[facet[0]]
+        for j in range(1, len(facet) - 1):
+            p1 = coords[facet[j]]
+            p2 = coords[facet[j + 1]]
+            n_candidate = np.cross(p1 - p0, p2 - p0)
+            if np.linalg.norm(n_candidate) > 0.0:
+                n = n_candidate
+                break
+        if n is None:
+            continue
         if normalize:
             norm = np.linalg.norm(n)
             n = n / norm if norm != 0.0 else n

fluxfem/solver/block_matrix.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+from collections.abc import Mapping as AbcMapping
+from typing import Any, Iterator, Mapping, Sequence, TypeAlias
+
+import numpy as np
+
+try:
+    import scipy.sparse as sp
+except Exception:  # pragma: no cover
+    sp = None
+
+from .block_system import split_block_matrix
+from .sparse import FluxSparseMatrix
+
+MatrixLike: TypeAlias = Any
+FieldKey: TypeAlias = str | int
+BlockMap: TypeAlias = dict[FieldKey, dict[FieldKey, MatrixLike]]
+
+
+def diag(**blocks: MatrixLike) -> dict[str, MatrixLike]:
+    return dict(blocks)
+
+
+def _infer_sizes_from_diag(diag_blocks: Mapping[FieldKey, MatrixLike]) -> dict[FieldKey, int]:
+    sizes = {}
+    for name, blk in diag_blocks.items():
+        if isinstance(blk, FluxSparseMatrix):
+            sizes[name] = int(blk.n_dofs)
+        elif sp is not None and sp.issparse(blk):
+            shape = blk.shape
+            if shape[0] != shape[1]:
+                raise ValueError(f"diag block {name} must be square, got {shape}")
+            sizes[name] = int(shape[0])
+        else:
+            arr = np.asarray(blk)
+            if arr.ndim != 2 or arr.shape[0] != arr.shape[1]:
+                raise ValueError(f"diag block {name} must be square, got {arr.shape}")
+            sizes[name] = int(arr.shape[0])
+    return sizes
+
+
+def _infer_format(blocks: AbcMapping[FieldKey, AbcMapping[FieldKey, MatrixLike]], fmt: str) -> str:
+    if fmt != "auto":
+        return fmt
+    for row in blocks.values():
+        for blk in row.values():
+            if isinstance(blk, FluxSparseMatrix):
+                return "flux"
+            if sp is not None and sp.issparse(blk):
+                return "csr"
+    return "dense"
+
+
+def _add_blocks(a: MatrixLike | None, b: MatrixLike | None) -> MatrixLike | None:
+    if a is None:
+        return b
+    if b is None:
+        return a
+    if isinstance(a, FluxSparseMatrix):
+        a = a.to_csr()
+    if isinstance(b, FluxSparseMatrix):
+        b = b.to_csr()
+    if sp is not None and sp.issparse(a):
+        if sp.issparse(b):
+            return a + b
+        return a + sp.csr_matrix(np.asarray(b))
+    if sp is not None and sp.issparse(b):
+        return sp.csr_matrix(np.asarray(a)) + b
+    return np.asarray(a) + np.asarray(b)
+
+
+def _transpose_block(block: MatrixLike, rule: str) -> MatrixLike:
+    if isinstance(block, FluxSparseMatrix):
+        if sp is None:
+            raise ImportError("scipy is required to transpose FluxSparseMatrix blocks.")
+        block = block.to_csr()
+    if sp is not None and sp.issparse(block):
+        out = block.T
+    else:
+        out = np.asarray(block).T
+    if rule == "H":
+        return out.conjugate()
+    return out
+
+
+class FluxBlockMatrix(AbcMapping[FieldKey, Mapping[FieldKey, MatrixLike]]):
+    """
+    Lazy block-matrix container that assembles on demand.
+    """
+
+    def __init__(
+        self,
+        blocks: BlockMap,
+        *,
+        sizes: Mapping[FieldKey, int],
+        order: Sequence[FieldKey] | None = None,
+        symmetric: bool = False,
+        transpose_rule: str = "T",
+    ) -> None:
+        self._blocks = blocks
+        self.sizes = {name: int(size) for name, size in sizes.items()}
+        self.field_order = tuple(order) if order is not None else tuple(self.sizes.keys())
+        self.symmetric = bool(symmetric)
+        self.transpose_rule = transpose_rule
+        for name in self.field_order:
+            if name not in self.sizes:
+                raise KeyError(f"Missing size for field '{name}'")
+
+    def __getitem__(self, key: FieldKey) -> Mapping[FieldKey, MatrixLike]:
+        return self._blocks[key]
+
+    def __iter__(self) -> Iterator[FieldKey]:
+        return iter(self._blocks)
+
+    def __len__(self) -> int:
+        return len(self._blocks)
+
+    @property
+    def blocks(self) -> BlockMap:
+        return self._blocks
+
+    def assemble(self, *, format: str = "flux") -> MatrixLike:
+        if format not in {"auto", "flux", "csr", "dense"}:
+            raise ValueError("format must be one of: auto, flux, csr, dense")
+        use_format = _infer_format(self._blocks, format)
+
+        offsets = {}
+        offset = 0
+        for name in self.field_order:
+            size = int(self.sizes[name])
+            offsets[name] = offset
+            offset += size
+        n_total = offset
+
+        def _block_shape(name_i: FieldKey, name_j: FieldKey) -> tuple[int, int]:
+            return (int(self.sizes[name_i]), int(self.sizes[name_j]))
+
+        if use_format == "flux":
+            rows_list = []
+            cols_list = []
+            data_list = []
+            for name_i in self.field_order:
+                row_blocks = self._blocks.get(name_i, {})
+                for name_j in self.field_order:
+                    blk = row_blocks.get(name_j)
+                    if blk is None:
+                        continue
+                    shape = _block_shape(name_i, name_j)
+                    if isinstance(blk, FluxSparseMatrix):
+                        if shape[0] != shape[1] or int(blk.n_dofs) != shape[0]:
+                            raise ValueError(f"Block {name_i},{name_j} has incompatible FluxSparseMatrix size")
+                        r = np.asarray(blk.pattern.rows, dtype=np.int64)
+                        c = np.asarray(blk.pattern.cols, dtype=np.int64)
+                        d = np.asarray(blk.data)
+                    elif sp is not None and sp.issparse(blk):
+                        coo = blk.tocoo()
+                        r = np.asarray(coo.row, dtype=np.int64)
+                        c = np.asarray(coo.col, dtype=np.int64)
+                        d = np.asarray(coo.data)
+                        if coo.shape != shape:
+                            raise ValueError(f"Block {name_i},{name_j} has shape {coo.shape}, expected {shape}")
+                    else:
+                        arr = np.asarray(blk)
+                        if arr.shape != shape:
+                            raise ValueError(f"Block {name_i},{name_j} has shape {arr.shape}, expected {shape}")
+                        r, c = np.nonzero(arr)
+                        d = arr[r, c]
+                    if r.size:
+                        rows_list.append(r + offsets[name_i])
+                        cols_list.append(c + offsets[name_j])
+                        data_list.append(d)
+            rows = np.concatenate(rows_list) if rows_list else np.asarray([], dtype=np.int32)
+            cols = np.concatenate(cols_list) if cols_list else np.asarray([], dtype=np.int32)
+            data = np.concatenate(data_list) if data_list else np.asarray([], dtype=float)
+            return FluxSparseMatrix(rows, cols, data, n_total)
+
+        if use_format == "csr" and sp is None:
+            raise ImportError("scipy is required for CSR block systems.")
+        block_rows = []
+        for name_i in self.field_order:
+            row = []
+            row_blocks = self._blocks.get(name_i, {})
+            for name_j in self.field_order:
+                blk = row_blocks.get(name_j)
+                shape = _block_shape(name_i, name_j)
+                if blk is None:
+                    if use_format == "csr":
+                        row.append(sp.csr_matrix(shape))
+                    else:
+                        row.append(np.zeros(shape, dtype=float))
+                    continue
+                if isinstance(blk, FluxSparseMatrix):
+                    if sp is None:
+                        raise ImportError("scipy is required to assemble sparse block systems.")
+                    blk = blk.to_csr()
+                if sp is not None and sp.issparse(blk):
+                    blk = blk.tocsr()
+                    if blk.shape != shape:
+                        raise ValueError(f"Block {name_i},{name_j} has shape {blk.shape}, expected {shape}")
+                    row.append(blk)
+                else:
+                    arr = np.asarray(blk)
+                    if arr.shape != shape:
+                        raise ValueError(f"Block {name_i},{name_j} has shape {arr.shape}, expected {shape}")
+                    if use_format == "csr":
+                        row.append(sp.csr_matrix(arr))
+                    else:
+                        row.append(arr)
+            block_rows.append(row)
+        if use_format == "csr":
+            return sp.bmat(block_rows, format="csr")
+        return np.block(block_rows)
+
+
+def make(
+    *,
+    diag: Mapping[FieldKey, MatrixLike] | Sequence[MatrixLike],
+    rel: Mapping[tuple[FieldKey, FieldKey], MatrixLike] | None = None,
+    add_contiguous: MatrixLike | None = None,
+    sizes: Mapping[FieldKey, int] | None = None,
+    symmetric: bool = False,
+    transpose_rule: str = "T",
+) -> FluxBlockMatrix:
+    """
+    Build a lazy FluxBlockMatrix from diagonal blocks, optional relations, and a full matrix.
+    """
+    if isinstance(diag, Mapping):
+        diag_map = dict(diag)
+    else:
+        diag_seq = list(diag)
+        if sizes is None:
+            diag_map = dict(zip(range(len(diag_seq)), diag_seq))
+        else:
+            order = tuple(sizes.keys())
+            if len(diag_seq) != len(order):
+                raise ValueError("diag sequence length must match sizes")
+            diag_map = dict(zip(order, diag_seq))
+
+    if sizes is None:
+        sizes = _infer_sizes_from_diag(diag_map)
+    order = tuple(sizes.keys())
+
+    if add_contiguous is None:
+        blocks = {name: {} for name in order}
+    else:
+        blocks = split_block_matrix(add_contiguous, sizes=sizes)
+
+    for name, blk in diag_map.items():
+        if name not in sizes:
+            raise KeyError(f"Unknown field '{name}' in diag")
+        blocks.setdefault(name, {})
+        blocks[name][name] = _add_blocks(blocks[name].get(name), blk)
+
+    if transpose_rule not in {"T", "H", "none"}:
+        raise ValueError("transpose_rule must be one of: T, H, none")
+
+    if rel is not None:
+        for (name_i, name_j), blk in rel.items():
+            if name_i not in sizes or name_j not in sizes:
+                raise KeyError(f"Unknown field in rel: {(name_i, name_j)}")
+            blocks.setdefault(name_i, {})
+            blocks[name_i][name_j] = _add_blocks(blocks[name_i].get(name_j), blk)
+            if symmetric and name_i != name_j:
+                if transpose_rule == "none":
+                    blocks.setdefault(name_j, {})
+                    blocks[name_j][name_i] = _add_blocks(blocks[name_j].get(name_i), blk)
+                else:
+                    blocks.setdefault(name_j, {})
+                    blocks[name_j][name_i] = _add_blocks(
+                        blocks[name_j].get(name_i),
+                        _transpose_block(blk, transpose_rule),
+                    )
+
+    return FluxBlockMatrix(
+        blocks,
+        sizes=sizes,
+        order=order,
+        symmetric=symmetric,
+        transpose_rule=transpose_rule,
+    )
+
+
+__all__ = ["FluxBlockMatrix", "diag", "make"]