warp-lang 1.9.1__py3-none-win_amd64.whl → 1.10.0rc2__py3-none-win_amd64.whl

warp/fem/dirichlet.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,190 +13,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Optional
+# TODO: Remove after cleaning up the public API.
 
-import warp as wp
-from warp.fem.linalg import array_axpy, symmetric_eigenvalues_qr
-from warp.sparse import BsrMatrix, bsr_assign, bsr_axpy, bsr_copy, bsr_mm, bsr_mv
-from warp.types import type_is_matrix, type_size
+from warp._src.fem import dirichlet as _dirichlet
 
 
-def normalize_dirichlet_projector(projector_matrix: BsrMatrix, fixed_value: Optional[wp.array] = None):
-    """
-    Scale projector so that it becomes idempotent, and apply the same scaling to fixed_value if provided
-    """
+def __getattr__(name):
+    from warp._src.utils import get_deprecated_api
 
-    if projector_matrix.nrow < projector_matrix.nnz or projector_matrix.ncol != projector_matrix.nrow:
-        raise ValueError("Projector must be a square diagonal matrix, with at most one non-zero block per row")
-
-    # Cast blocks to matrix type if necessary
-    projector_values = projector_matrix.values
-    if not type_is_matrix(projector_values.dtype):
-        projector_values = wp.array(
-            data=None,
-            ptr=projector_values.ptr,
-            capacity=projector_values.capacity,
-            device=projector_values.device,
-            dtype=wp.mat(shape=projector_matrix.block_shape, dtype=projector_matrix.scalar_type),
-            shape=projector_values.shape[0],
-        )
-
-    if fixed_value is None:
-        wp.launch(
-            kernel=_normalize_dirichlet_projector_kernel,
-            dim=projector_matrix.nrow,
-            device=projector_values.device,
-            inputs=[projector_matrix.offsets, projector_matrix.columns, projector_values],
-        )
-
-    else:
-        if fixed_value.shape[0] != projector_matrix.nrow:
-            raise ValueError("Fixed value array must be of length equal to the number of rows of blocks")
-
-        if type_size(fixed_value.dtype) == 1:
-            # array of scalars, convert to 1d array of vectors
-            fixed_value = wp.array(
-                data=None,
-                ptr=fixed_value.ptr,
-                capacity=fixed_value.capacity,
-                device=fixed_value.device,
-                dtype=wp.vec(length=projector_matrix.block_shape[0], dtype=projector_matrix.scalar_type),
-                shape=fixed_value.shape[0],
-            )
-
-        wp.launch(
-            kernel=_normalize_dirichlet_projector_and_values_kernel,
-            dim=projector_matrix.nrow,
-            device=projector_values.device,
-            inputs=[projector_matrix.offsets, projector_matrix.columns, projector_values, fixed_value],
-        )
-
-
-def project_system_rhs(
-    system_matrix: BsrMatrix, system_rhs: wp.array, projector_matrix: BsrMatrix, fixed_value: Optional[wp.array] = None
-):
-    """Projects the right-hand-side of a linear system to enforce Dirichlet boundary conditions
-
-    ``rhs = (I - projector) * ( rhs - system * projector * fixed_value) + projector * fixed_value``
-    """
-
-    rhs_tmp = wp.empty_like(system_rhs)
-    rhs_tmp.assign(system_rhs)
-
-    if fixed_value is None:
-        system_rhs.zero_()
-    else:
-        bsr_mv(A=projector_matrix, x=fixed_value, y=system_rhs, alpha=1.0, beta=0.0)
-
-    bsr_mv(A=system_matrix, x=system_rhs, y=rhs_tmp, alpha=-1.0, beta=1.0)
-
-    # here rhs_tmp = system_rhs - system_matrix * projector * fixed_value
-    # system_rhs = projector * fixed_value
-    array_axpy(x=rhs_tmp, y=system_rhs, alpha=1.0, beta=1.0)
-    bsr_mv(A=projector_matrix, x=rhs_tmp, y=system_rhs, alpha=-1.0, beta=1.0)
-
-
-def project_system_matrix(system_matrix: BsrMatrix, projector_matrix: BsrMatrix):
-    """Projects the right-hand-side of a linear system to enforce Dirichlet boundary conditions
-
-    ``system = (I - projector) * system * (I - projector) + projector``
-    """
-
-    complement_system = bsr_copy(system_matrix)
-    bsr_mm(x=projector_matrix, y=system_matrix, z=complement_system, alpha=-1.0, beta=1.0)
-
-    bsr_assign(dest=system_matrix, src=complement_system)
-    bsr_axpy(x=projector_matrix, y=system_matrix)
-    bsr_mm(x=complement_system, y=projector_matrix, z=system_matrix, alpha=-1.0, beta=1.0)
-
-
-def project_linear_system(
-    system_matrix: BsrMatrix,
-    system_rhs: wp.array,
-    projector_matrix: BsrMatrix,
-    fixed_value: Optional[wp.array] = None,
-    normalize_projector=True,
-):
-    """
-    Projects both the left-hand-side and right-hand-side of a linear system to enforce Dirichlet boundary conditions
-
-    If normalize_projector is True, first apply scaling so that the projector_matrix is idempotent
-    """
-    if normalize_projector:
-        normalize_dirichlet_projector(projector_matrix, fixed_value)
-
-    project_system_rhs(system_matrix, system_rhs, projector_matrix, fixed_value)
-    project_system_matrix(system_matrix, projector_matrix)
-
-
-@wp.func
-def _normalize_projector_and_value(A: Any, b: Any):
-    # Do a modal decomposition of the left and right hand side,
-    # Make lhs an orthogonal projection and apply corresponding scaling to righ-hand-side
-
-    eps = wp.trace(A) * A.dtype(1.0e-6)
-
-    diag, ev = symmetric_eigenvalues_qr(A, eps * eps)
-
-    zero = A.dtype(0)
-    A_unitary = type(A)(zero)
-    b_normalized = type(b)(zero)
-
-    for k in range(b.length):
-        if diag[k] > eps:  # ignore small eigenmodes
-            v = ev[k]
-            A_unitary += wp.outer(v, v)
-            b_normalized += wp.dot(v, b) / diag[k] * v
-
-    return A_unitary, b_normalized
-
-
-@wp.kernel
-def _normalize_dirichlet_projector_and_values_kernel(
-    offsets: wp.array(dtype=int),
-    columns: wp.array(dtype=int),
-    block_values: wp.array(dtype=Any),
-    fixed_values: wp.array(dtype=Any),
-):
-    row = wp.tid()
-
-    beg = offsets[row]
-    end = offsets[row + 1]
-
-    if beg == end:
-        return
-
-    diag = wp.lower_bound(columns, beg, end, row)
-
-    if diag < end:
-        if columns[diag] == row:
-            P = block_values[diag]
-
-            P_norm, v_norm = _normalize_projector_and_value(P, fixed_values[row])
-
-            block_values[diag] = P_norm
-            fixed_values[row] = v_norm
-
-
-@wp.kernel
-def _normalize_dirichlet_projector_kernel(
-    offsets: wp.array(dtype=int),
-    columns: wp.array(dtype=int),
-    block_values: wp.array(dtype=Any),
-):
-    row = wp.tid()
-
-    beg = offsets[row]
-    end = offsets[row + 1]
-
-    if beg == end:
-        return
-
-    diag = wp.lower_bound(columns, beg, end, row)
-
-    if diag < end:
-        if columns[diag] == row:
-            P = block_values[diag]
-
-            P_norm, v_norm = _normalize_projector_and_value(P, type(P[0])())
-            block_values[diag] = P_norm
+    return get_deprecated_api(_dirichlet, "wp.fem", name)

warp/fem/field/__init__.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,113 +13,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Union
+# isort: skip_file
 
-from warp.fem.domain import Cells, GeometryDomain
-from warp.fem.space import FunctionSpace, SpacePartition, SpaceRestriction, make_space_partition, make_space_restriction
+from . import field as field
 
-from .field import DiscreteField, FieldLike, GeometryField, ImplicitField, NonconformingField, SpaceField, UniformField
-from .nodal_field import NodalField
-from .restriction import FieldRestriction
-from .virtual import LocalTestField, LocalTrialField, TestField, TrialField
-
-
-def make_restriction(
-    field: DiscreteField,
-    space_restriction: Optional[SpaceRestriction] = None,
-    domain: Optional[GeometryDomain] = None,
-    device=None,
-) -> FieldRestriction:
-    """
-    Restricts a discrete field to a subset of elements.
-
-    Args:
-        field: the discrete field to restrict
-        space_restriction: the function space restriction defining the subset of elements to consider
-        domain: if ``space_restriction`` is not provided, the :py:class:`Domain` defining the subset of elements to consider
-        device: Warp device on which to perform and store computations
-
-    Returns:
-        the field restriction
-    """
-
-    if space_restriction is None:
-        space_restriction = make_space_restriction(space_partition=field.space_partition, domain=domain, device=device)
-
-    return FieldRestriction(field=field, space_restriction=space_restriction)
-
-
-def make_test(
-    space: FunctionSpace,
-    space_restriction: Optional[SpaceRestriction] = None,
-    space_partition: Optional[SpacePartition] = None,
-    domain: Optional[GeometryDomain] = None,
-    device=None,
-) -> TestField:
-    """
-    Constructs a test field over a function space or its restriction
-
-    Args:
-        space: the function space
-        space_restriction: restriction of the space topology to a domain
-        space_partition: if `space_restriction` is ``None``, the optional subset of node indices to consider
-        domain: if `space_restriction` is ``None``, optional subset of elements to consider
-        device: Warp device on which to perform and store computations
-
-    Returns:
-        the test field
-    """
-
-    if space_restriction is None:
-        space_restriction = make_space_restriction(
-            space_topology=space.topology, space_partition=space_partition, domain=domain, device=device
-        )
-
-    return TestField(space_restriction=space_restriction, space=space)
-
-
-def make_trial(
-    space: FunctionSpace,
-    space_restriction: Optional[SpaceRestriction] = None,
-    space_partition: Optional[SpacePartition] = None,
-    domain: Optional[GeometryDomain] = None,
-) -> TrialField:
-    """
-    Constructs a trial field over a function space or partition
-
-    Args:
-        space: the function space or function space restriction
-        space_restriction: restriction of the space topology to a domain
-        space_partition: if `space_restriction` is ``None``, the optional subset of node indices to consider
-        domain: if `space_restriction` is ``None``, optional subset of elements to consider
-        device: Warp device on which to perform and store computations
-
-    Returns:
-        the trial field
-    """
-
-    if space_restriction is not None:
-        domain = space_restriction.domain
-        space_partition = space_restriction.space_partition
-
-    if space_partition is None:
-        if domain is None:
-            domain = Cells(geometry=space.geometry)
-        space_partition = make_space_partition(
-            space_topology=space.topology, geometry_partition=domain.geometry_partition
-        )
-    elif domain is None:
-        domain = Cells(geometry=space_partition.geo_partition)
-
-    return TrialField(space, space_partition, domain)
-
-
-def make_discrete_field(
-    space: FunctionSpace,
-    space_partition: Optional[SpacePartition] = None,
-) -> DiscreteField:
-    """Constructs  a zero-initialized discrete field over a function space or partition
-
-    See also: :meth:`warp.fem.FunctionSpace.make_field`
-    """
-    return space.make_field(space_partition=space_partition)
+from warp._src.fem.field import FieldRestriction as FieldRestriction
+from warp._src.fem.field import GeometryField as GeometryField
+from warp._src.fem.field import SpaceField as SpaceField
+from warp._src.fem.field import TestField as TestField
+from warp._src.fem.field import TrialField as TrialField