capytaine 3.0.0a1__cp314-cp314-macosx_15_0_x86_64.whl

capytaine/meshes/visualization.py

@@ -0,0 +1,353 @@
+# Copyright 2025 Mews Labs
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+from typing import Optional, List
+
+import numpy as np
+
+from capytaine import __version__
+from capytaine.tools.optional_imports import import_optional_dependency
+
+
+def show_3d(mesh, *, backend=None, **kwargs):
+    """Dispatch the 3D viewing to one of the available backends below."""
+    backends_functions = {
+            "pyvista": show_pyvista,
+            "matplotlib": show_matplotlib,
+            }
+    if backend is not None:
+        if backend in backends_functions:
+            return backends_functions[backend](mesh, **kwargs)
+        else:
+            raise NotImplementedError(f"Backend '{backend}' is not implemented.")
+    else:
+        for backend in backends_functions:
+            try:
+                return backends_functions[backend](mesh, **kwargs)
+            except (NotImplementedError, ImportError):
+                pass
+            raise NotImplementedError(f"No compatible backend found to show the mesh {mesh}"
+                                      "Consider installing `matplotlib` or `pyvista`.")
+
+
+def show_pyvista(
+    mesh,
+    *,
+    ghost_meshes=None,
+    plotter=None,
+    normal_vectors=False,
+    display_free_surface=True,
+    water_depth=np.inf,
+    color_field=None,
+    cbar_label="",
+    **kwargs
+) -> Optional["pv.Plotter"]:  # noqa: F821
+    """
+    Visualize the mesh using PyVista.
+
+    PyVista default keyboards controls: https://docs.pyvista.org/api/plotting/plotting
+
+    Parameters
+    ----------
+    mesh : Mesh
+        The mesh object to visualize.
+    ghost_meshes: List[Mesh], optional
+        Additional meshes, shown in transparency
+    plotter: pv.Plotter, optional
+        If provided, use this PyVista plotter and return it at the end.
+        Otherwise a new one is created and the 3D view is displayed at the end.
+    normal_vectors: bool, optional
+        If True, display normal vector (default: True)
+    display_free_surface: bool, optional
+        If True, display free surface and if `water_depth` is finite display the sea bottom.
+        (default: True)
+    water_depth: float, optional
+        Where to display the sea bottom if `display_free_surface` is True
+    color_field: array of shape (nb_faces, ), optional
+        Scalar field to be plot on the mesh.
+    cmap: matplotlib colormap, optional
+        Colormap to use for scalar field plotting.
+    cbar_label: string, optional
+        Label for colorbar show color field scale
+    kwargs : additional optional arguments
+        Additional arguments passed to PyVista's add_mesh methods for customization (e.g. mesh color).
+    """
+    pv = import_optional_dependency("pyvista")
+
+    all_meshes_in_scene: List[Mesh] = [mesh] if ghost_meshes is None else [mesh, *ghost_meshes]
+    pv_meshes = [m.export_to_pyvista() for m in all_meshes_in_scene]
+
+    if color_field is not None and isinstance(color_field, np.ndarray):
+        acc_faces = 0
+        # Split the content of color_fields into the meshes in the scene
+        for m in pv_meshes:
+            m.cell_data["color_field"] = color_field[acc_faces:acc_faces+m.n_cells]
+            acc_faces = acc_faces + m.n_cells
+
+    if plotter is None:
+        default_plotter = True
+        plotter = pv.Plotter()
+    else:
+        default_plotter = False
+
+    if color_field is not None:
+        kwargs.setdefault("scalars", "color_field")
+    kwargs.setdefault("scalar_bar_args", {"title": cbar_label})
+    plotter.add_mesh(pv_meshes[0], name="hull", show_edges=True, **kwargs)
+
+    for i_ghost, g_mesh in enumerate(pv_meshes[1:]):
+        plotter.add_mesh(
+                g_mesh,
+                name=f"symmetric_hull_{i_ghost}",
+                opacity=0.4,
+                show_edges=False,
+                **kwargs
+                )
+
+    # NORMALS
+    def show_normals():
+        mini = mesh.vertices.min()
+        maxi = mesh.vertices.max()
+        plotter.add_arrows(
+            mesh.faces_centers,
+            mesh.faces_normals,
+            name="normals",
+            mag=0.04*(maxi-mini),
+            show_scalar_bar=False
+        )
+
+    def toggle_normals():
+        nonlocal normal_vectors
+        if normal_vectors:
+            normal_vectors = False
+            plotter.remove_actor('normals')
+        else:
+            normal_vectors = True
+            show_normals()
+
+    if normal_vectors:
+        show_normals()
+    plotter.add_key_event("n", lambda : toggle_normals())
+
+    scene_min = np.min([m.vertices[:, :].min(axis=0) for m in all_meshes_in_scene], axis=0)
+    scene_max = np.max([m.vertices[:, :].max(axis=0) for m in all_meshes_in_scene], axis=0)
+
+    # FREE SURFACE
+    def show_free_surface():
+        center = (scene_min[:2] + scene_max[:2]) / 2
+        diam = 1.1*(scene_max[:2] - scene_min[:2])
+        plane = pv.Plane(center=(*center, 0), direction=(0, 0, 1), i_size=diam[0], j_size=diam[1])
+        plotter.add_mesh(plane, color="blue", opacity=0.5, name="display_free_surface")
+        if water_depth != np.inf:
+            plane = pv.Plane(center=(*center, -water_depth), direction=(0, 0, 1), i_size=diam[0], j_size=diam[1])
+            plotter.add_mesh(plane, color="brown", opacity=0.5, name="display_sea_bottom")
+
+
+    def toggle_free_surface():
+        nonlocal display_free_surface
+        if display_free_surface:
+            display_free_surface = False
+            plotter.remove_actor('display_free_surface')
+            if water_depth != np.inf:
+                plotter.remove_actor('display_sea_bottom')
+        else:
+            display_free_surface = True
+            show_free_surface()
+
+    if display_free_surface:
+        show_free_surface()
+
+    plotter.add_key_event("h", lambda : toggle_free_surface())
+
+    # BOUNDS
+    def show_bounds():
+        plotter.show_bounds(grid='back', location='outer', n_xlabels=2, n_ylabels=2, n_zlabels=2)
+
+    bounds = True
+    show_bounds()
+    def toggle_bounds():
+        nonlocal bounds
+        if bounds:
+            plotter.remove_bounds_axes()
+            bounds = False
+        else:
+            show_bounds()
+            plotter.update()
+            bounds = True
+
+
+    plotter.add_key_event("b", lambda: toggle_bounds())
+
+    plotter.add_key_event("T", lambda : plotter.view_xy())
+    plotter.add_key_event("B", lambda : plotter.view_xy(negative=True))
+    plotter.add_key_event("S", lambda : plotter.view_xz())
+    plotter.add_key_event("P", lambda : plotter.view_xz(negative=True))
+    plotter.add_key_event("F", lambda : plotter.view_yz())
+    plotter.add_key_event("R", lambda : plotter.view_yz(negative=True))
+
+    view_clipping = {'x': 0, 'y': 0}  # 0 = no clipping, +1 clipping one side, -1 clipping other side
+    def clipped_mesh():
+        nonlocal view_clipping
+        clipped_pv_mesh = pv_meshes[0]
+        for dir in ['x', 'y']:
+            if view_clipping[dir] == 1:
+                clipped_pv_mesh = clipped_pv_mesh.clip(dir)
+            elif view_clipping[dir] == -1:
+                clipped_pv_mesh = clipped_pv_mesh.clip("-" + dir)
+        return clipped_pv_mesh
+
+    def toggle_view_clipping(dir):
+        nonlocal view_clipping
+        if view_clipping[dir] == 0:
+            view_clipping[dir] = +1
+        elif view_clipping[dir] == +1:
+            view_clipping[dir] = -1
+        else:
+            view_clipping[dir] = 0
+        plotter.add_mesh(clipped_mesh(), name="hull", show_edges=True, **kwargs)
+
+    plotter.add_key_event("X", lambda : toggle_view_clipping("x"))
+    plotter.add_key_event("Y", lambda : toggle_view_clipping("y"))
+
+    plotter.add_text(
+        f"Capytaine version {__version__}\n\n"
+        """Keyboard controls:
+        b: toggle scale and bounding box
+        h: toggle free surface (and sea bottom if water depth was given)
+        n: toggle normal vectors
+        T,B,P,S,F,R: view [T]op, [B]ottom, [P]ort, [S]tarboard, [F]ront, [R]ear
+        X, Y: toggle displaying clipped mesh in x or y direction
+        q: exit
+        """,
+        position="upper_left",
+        font_size=10
+    )
+    plotter.show_axes()  # xyz in bottom left corner
+
+    if default_plotter:
+        plotter.show()
+    else:
+        return plotter
+
+
+def show_matplotlib(
+    mesh,
+    *,
+    ghost_meshes=None,
+    ax=None,
+    bounding_box=None,
+    normal_vectors=False,
+    scale_normal_vector=None,
+    color_field=None,
+    cmap=None,
+    cbar_label=None,
+    **kwargs
+):
+    """
+    Visualize the mesh using Matplotlib.
+
+    Parameters
+    ----------
+    mesh : Mesh
+        The mesh object to visualize.
+    ghost_meshes: List[Mesh], optional
+        Additional meshes. In the matplotlib viewer, they are just merged with the main mesh.
+    ax: matplotlib axis
+        The 3d axis in which to plot the mesh. If not provided, create a new one.
+    bounding_box: tuple[tuple[int]], optional
+        Min and max coordinates values to display in each three dimensions.
+    normal_vectors: bool, optional
+        If True, display normal vector.
+    scale_normal_vector: array of shape (nb_faces, ), optional
+        Scale separately each of the normal vectors.
+    color_field: array of shape (nb_faces, ), optional
+        Scalar field to be plot on the mesh (optional).
+    cmap: matplotlib colormap, optional
+        Colormap to use for scalar field plotting.
+    cbar_label: string, optional
+        Label for colorbar show color field scale
+
+    Other parameters are passed to Poly3DCollection.
+    """
+    matplotlib = import_optional_dependency("matplotlib")
+    plt = importlib.import_module("matplotlib.pyplot")
+    cm = importlib.import_module("matplotlib.cm")
+
+    mpl_toolkits = import_optional_dependency("mpl_toolkits", package_name="matplotlib")
+    Poly3DCollection = mpl_toolkits.mplot3d.art3d.Poly3DCollection
+
+    default_axis = ax is None
+    if default_axis:
+        fig = plt.figure(layout="constrained")
+        ax = fig.add_subplot(111, projection="3d")
+        ax.set_box_aspect([1, 1, 1])  # Equal aspect ratio
+
+    all_meshes_in_scene: List[Mesh] = [mesh] if ghost_meshes is None else [mesh, *ghost_meshes]
+
+    faces = []
+    for m in all_meshes_in_scene:
+        for face in m.faces:
+            vertices = [m.vertices[int(index_vertex), :] for index_vertex in face]
+            faces.append(vertices)
+
+    if color_field is None:
+        if 'facecolors' not in kwargs:
+            kwargs['facecolors'] = "yellow"
+    else:
+        if cmap is None:
+            cmap = matplotlib.colormaps['coolwarm']
+        m = cm.ScalarMappable(cmap=cmap)
+        m.set_array([min(color_field), max(color_field)])
+        m.set_clim(vmin=min(color_field), vmax=max(color_field))
+        colors = m.to_rgba(color_field)
+        kwargs['facecolors'] = colors
+    kwargs.setdefault("edgecolor", "k")
+
+    ax.add_collection3d(Poly3DCollection(faces, **kwargs))
+
+    if color_field is not None:
+        cbar = plt.colorbar(m, ax=ax)
+        if cbar_label is not None:
+            cbar.set_label(cbar_label)
+
+    # Plot normal vectors.
+    if normal_vectors:
+        if scale_normal_vector is not None:
+            vectors = (scale_normal_vector * mesh.faces_normals.T).T
+        else:
+            vectors = mesh.faces_normals
+        ax.quiver(*zip(*mesh.faces_centers), *zip(*vectors), length=0.2)
+
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+
+    if bounding_box is None:
+        # auto cube around mesh
+        mini = mesh.vertices.min(axis=0)
+        maxi = mesh.vertices.max(axis=0)
+        center = (mini + maxi) / 2
+        radius = (maxi - mini).max() / 2
+        ax.set_xlim(center[0] - radius, center[0] + radius)
+        ax.set_ylim(center[1] - radius, center[1] + radius)
+        ax.set_zlim(center[2] - radius, center[2] + radius)
+    else:
+        (xmin, xmax), (ymin, ymax), (zmin, zmax) = bounding_box
+        ax.set_xlim(xmin, xmax)
+        ax.set_ylim(ymin, ymax)
+        ax.set_zlim(zmin, zmax)
+
+    if default_axis:
+        plt.show()

capytaine/post_pro/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (C) 2017-2019 Matthieu Ancellin
+# See LICENSE file at <https://github.com/mancellin/capytaine>
+
+from capytaine.post_pro.rao import rao
+from capytaine.post_pro.impedance import impedance, rao_transfer_function
+from capytaine.post_pro.kochin import compute_kochin

capytaine/post_pro/free_surfaces.py

@@ -0,0 +1,85 @@
+"""This module implements objects describing a mesh on which the free surface elevation will be computed."""
+# Copyright (C) 2017-2019 Matthieu Ancellin
+# See LICENSE file at <https://github.com/mancellin/capytaine>
+
+import logging
+from itertools import product
+
+import numpy as np
+
+from capytaine.meshes.meshes import Mesh
+
+LOG = logging.getLogger(__name__)
+
+
+class FreeSurface():
+    """A cartesian mesh on which the free surface elevation will be computed.
+
+    Has a :code:`mesh` attribute to behave kind of like FloatingBody when
+    building of the influence matrix.
+
+    Parameters
+    ----------
+    x_range: Tuple[float, float], optional
+        extreme values of the mesh in the x direction
+    nx: int, optional
+        number of cells in the x direction
+    y_range: Tuple[float, float], optional
+        extreme values of the mesh in the y direction
+    ny: int, optional
+        number of cells in the y direction
+    name: string, optional
+        a name for the free surface object
+
+
+    .. todo:: Generalize to non-cartesian meshes.
+              In particular, it could be of interest to build meshes having the
+              same symmetry as a given floating body to speed up the
+              construction of the influence matrix.
+
+    .. seealso::
+
+        :meth:`~capytaine.bem.nemoh.Nemoh.get_free_surface_elevation`
+            The main function requiring a FreeSurface object.
+    """
+    def __init__(self, x_range=(-50.0, 50.0), nx=10, y_range=(-50.0, 50.0), ny=10, name=None):
+        self.x_range = x_range
+        self.nx = nx
+        self.y_range = y_range
+        self.ny = ny
+
+        self.name = name
+
+        self.mesh = self._generate_mesh()
+
+    def _generate_mesh(self):
+        """Generate a 2D cartesian mesh."""
+        nodes = np.zeros(((self.nx+1)*(self.ny+1), 3), dtype=float)
+        panels = np.zeros((self.nx*self.ny, 4), dtype=int)
+
+        X = np.linspace(*self.x_range, self.nx+1)
+        Y = np.linspace(*self.y_range, self.ny+1)
+        for i, (x, y, z) in enumerate(product(X, Y, [0.0])):
+            nodes[i, :] = x, y, z
+
+        for k, (i, j) in enumerate(product(range(0, self.nx), range(0, self.ny))):
+            panels[k, :] = (j+i*(self.ny+1),
+                            (j+1)+i*(self.ny+1),
+                            (j+1)+(i+1)*(self.ny+1),
+                            j+(i+1)*(self.ny+1))
+
+        return Mesh(nodes, panels, name=f"{self.name}_mesh")
+
+    @property
+    def area(self):
+        """The total area covered by the mesh."""
+        return (np.abs(self.x_range[1] - self.x_range[0])
+                * np.abs(self.y_range[1] - self.y_range[0]))
+
+    def incoming_waves(self, problem: "DiffractionProblem") -> np.ndarray:
+        """Free surface elevation of the undisturbed incoming waves
+        for a given diffraction problem.
+        Kept for legacy, but not recommended for use.
+        """
+        from capytaine.bem.airy_waves import airy_waves_free_surface_elevation
+        return airy_waves_free_surface_elevation(self, problem)

capytaine/post_pro/impedance.py

@@ -0,0 +1,92 @@
+"""Computation of the impendance matrix."""
+# Copyright (C) 2017-2019 Matthieu Ancellin
+# See LICENSE file at <https://github.com/mancellin/capytaine>
+
+import logging
+
+LOG = logging.getLogger(__name__)
+
+
+def rao_transfer_function(dataset, dissipation=None, stiffness=None):
+    """Complex-valued matrix used for the computation of the RAO.
+
+    Parameters
+    ----------
+    dataset: xarray Dataset
+        The hydrodynamical dataset.
+        This function supposes that variables named 'inertia_matrix' and 'hydrostatic_stiffness' are in the dataset.
+        Other variables can be computed by Capytaine, by those two should be manually added to the dataset.
+    dissipation: array, optional
+        An optional dissipation matrix (e.g. Power Take Off) to be included in the transfer function.
+        Default: none.
+    stiffness: array, optional
+        An optional stiffness matrix (e.g. mooring stiffness) to be included in the transfer function.
+        Default: none.
+
+    Returns
+    -------
+    xarray DataArray
+        The matrix as an array depending of omega and the degrees of freedom.
+    """
+
+    if not hasattr(dataset, 'inertia_matrix'):
+        raise AttributeError('Computing the impedance matrix requires an `inertia_matrix` matrix to be defined in the hydrodynamical dataset')
+
+    if not hasattr(dataset, 'hydrostatic_stiffness'):
+        raise AttributeError('Computing the impedance matrix requires an `hydrostatic_stiffness` matrix to be defined in the hydrodynamical dataset')
+
+    if 'encounter_omega' in dataset.coords:
+        omega = dataset.coords['encounter_omega']
+    else:
+        omega = dataset.coords['omega']
+
+    # ASSEMBLE MATRICES
+    H = (-omega**2*(dataset['inertia_matrix'] + dataset['added_mass'])
+         - 1j*omega*dataset['radiation_damping']
+         + dataset['hydrostatic_stiffness'])
+
+    if dissipation is not None:
+        H = H - 1j*omega*dissipation
+
+    if stiffness is not None:
+        H = H + stiffness
+
+    return H
+
+
+def impedance(dataset, dissipation=None, stiffness=None):
+    """Complex-valued mechanical impedance matrix.
+    See Falnes for more theoretical details::
+
+        @book{falnes2002ocean,
+              title={Ocean Waves and Oscillating Systems: Linear Interactions Including Wave-Energy Extraction},
+              author={Falnes, J.},
+              isbn={9781139431934},
+              url={https://books.google.com/books?id=bl1FyQjCklgC},
+              year={2002},
+              publisher={Cambridge University Press}
+        }
+
+    Parameters
+    ----------
+    dataset: xarray Dataset
+        The hydrodynamical dataset.
+        This function supposes that variables named 'inertia_matrix' and 'hydrostatic_stiffness' are in the dataset.
+        Other variables can be computed by Capytaine, by those two should be manually added to the dataset.
+    dissipation: array, optional
+        An optional dissipation matrix (e.g. Power Take Off) to be included in the impedance.
+        Default: none.
+    stiffness: array, optional
+        An optional stiffness matrix (e.g. mooring stiffness) to be included in the impedance.
+        Default: none.
+
+    Returns
+    -------
+    xarray DataArray
+        The impedance as an array depending of omega and the degrees of freedom.
+    """
+    if 'encounter_omega' in dataset.coords:
+        omega = dataset.coords['encounter_omega']
+    else:
+        omega = dataset.coords['omega']
+    return 1/(-1j * omega) * rao_transfer_function(dataset, dissipation, stiffness)

capytaine/post_pro/kochin.py

@@ -0,0 +1,54 @@
+"""Computation of the Kochin function."""
+# Copyright (C) 2017-2019 Matthieu Ancellin
+# See LICENSE file at <https://github.com/capytaine/capytaine>
+
+import logging
+import numpy as np
+
+LOG = logging.getLogger(__name__)
+
+def compute_kochin(result, theta, ref_point=(0.0, 0.0)):
+    """Compute the far field coefficient
+
+    Parameters
+    ----------
+    result: LinearPotentialFlowResult
+        solved potential flow problem
+    theta: float or 1-dim array of floats
+        angles at which the coefficient is computed
+    ref_point: couple of float, optional
+        point of reference around which the far field coefficient is computed
+
+    Returns
+    -------
+    H: same type as theta
+        values of the Kochin function
+    """
+
+    if result.forward_speed != 0.0:
+        LOG.warning("Kochin functions with forward speed have never been validated.")
+
+    if result.sources is None:
+        raise ValueError(f"""The values of the sources of {result} cannot been found.
+        They have not been stored by the solver either because the direct method has been used or the option keep_details=True have not been set.
+        Please re-run the resolution with `method='indirect'` and `keep_details=True`.""")
+
+    k = result.wavenumber
+    h = result.water_depth
+
+    # omega_bar.shape = (nb_faces_including_lid, 2) @ (2, nb_theta)
+    omega_bar = (result.body.mesh_including_lid.faces_centers[:, 0:2] - ref_point) @ (np.cos(theta), np.sin(theta))
+
+    if 0 <= k*h < 20:
+        cih = np.cosh(k*(result.body.mesh_including_lid.faces_centers[:, 2]+h))/np.cosh(k*h)
+    else:
+        cih = np.exp(k*result.body.mesh_including_lid.faces_centers[:, 2])
+
+    # cih.shape = (nb_faces_including_lid,)
+    # omega_bar.T.shape = (nb_theta, nb_faces_including_lid)
+    # result.body.mesh.faces_areas.shape = (nb_faces_including_lid,)
+    zs = cih * np.exp(-1j * k * omega_bar.T) * result.body.mesh_including_lid.faces_areas
+
+    # zs.shape = (nb_theta, nb_faces_including_lid)
+    # result.sources.shape = (nb_faces_including_lid,)
+    return zs @ result.sources/(4*np.pi)

capytaine/post_pro/rao.py

@@ -0,0 +1,60 @@
+"""Experimental function to compute the Response Amplitude Operator."""
+# Copyright (C) 2017-2019 Matthieu Ancellin
+# See LICENSE file at <https://github.com/mancellin/capytaine>
+
+import logging
+
+import numpy as np
+import xarray as xr
+from capytaine.post_pro.impedance import rao_transfer_function
+
+LOG = logging.getLogger(__name__)
+
+
+def rao(dataset, wave_direction=None, dissipation=None, stiffness=None):
+    """Response Amplitude Operator.
+
+    Parameters
+    ----------
+    dataset: xarray Dataset
+        The hydrodynamical dataset.
+        This function supposes that variables named 'inertia_matrix' and 'hydrostatic_stiffness' are in the dataset.
+        Other variables can be computed by Capytaine, by those two should be manually added to the dataset.
+    wave_direction: float, optional
+        Select a wave directions for the computation. (Not recommended, kept for legacy.)
+        Default: all wave directions in the dataset.
+    dissipation: array, optional
+        An optional dissipation matrix (e.g. Power Take Off) to be included in the RAO.
+        Default: none.
+    stiffness: array, optional
+        An optional stiffness matrix (e.g. mooring stiffness) to be included in the RAO.
+        Default: none.
+
+    Returns
+    -------
+    xarray DataArray
+        The RAO as an array depending of omega and the degree of freedom.
+    """
+
+    # ASSEMBLE MATRICES
+    H = rao_transfer_function(dataset, dissipation, stiffness)
+    fex = dataset.excitation_force
+
+    LOG.info("Compute RAO.")
+
+    # SOLVE LINEAR SYSTEMS
+    # Match dimensions of the arrays to be sure to solve the right systems.
+    H, fex = xr.broadcast(H, fex, exclude=["radiating_dof", "influenced_dof"])
+    H = H.transpose(..., 'radiating_dof', 'influenced_dof')
+    fex = fex.transpose(...,  'influenced_dof')
+
+    if wave_direction is not None:  # Legacy behavior for backward compatibility
+        H = H.sel(wave_direction=wave_direction)
+        fex = fex.sel(wave_direction=wave_direction)
+
+    # Solve and add coordinates
+    rao_dims = [d for d in H.dims if d != 'influenced_dof']
+    rao_coords = {c: H.coords[c] for c in H.coords if c != 'influenced_dof'}
+    rao = xr.DataArray(np.linalg.solve(H.values, fex.values[..., np.newaxis])[..., 0], coords=rao_coords, dims=rao_dims)
+
+    return rao