Plotter: multiple mesh (#130)

* meshes_container.plot()

* raise if meshes_container and fields_container does not have the same scope (MeshesContainer.plot(fields_container)

* Fix unit test

* Add docstring to plotter.add_field() and plotter.show_figure()

* use field support in case of plotter.add_field(field, mesh=none) is set

* meshes_container.plot() without data, docstring added

* plotter.add_mesh() and testing added

* path plot working

* Plotter updated (fixes for path)

* Fix unit tests -> all working

* Remove the mesh attribute from the plotter

* flake8 compliancy

* Fix doc API strings

* Flake8 compliancy

* flake8 compliancy

* Fix examples

* Black refactore of plotter.py and meshes_container.py to be flake8 compliant

* Re-run ci/cd

* Revert "Fix examples"

This reverts commit 431c100.

* Update plotter.__init__ to keep the mesh parameter as an argument taken into account

* Fix flake8 compliancy (remove try import pyvista in the plot_contour method)

* Argument order for plotter.plot_contour (fix unit tests)

* Fix indentation

* remove mesh=

* create _InternalPlotter and DpfPlotter

* Update meshes_container plotting

* update tests

* fix meshes_container.plot()

* meshes_container.plot() -> notebook and colors supported

* CI/CD fixes

* Fix meshes_container.plot(fc) (colors)

* Add examples. Still missin: example to compare results

* Flake8 compliancy

* Fix CI/CD (hasattr(pl, scalar_bar) issue

* Example that compares results

* Refactore examples - plotting section added

* Change model that we plot the path on

* Flake8 compliancy

* Add README.txt

* Update tests/test_plotter.py

Co-authored-by: Alex Kaszynski <[email protected]>

* Update tests/test_plotter.py

Co-authored-by: Alex Kaszynski <[email protected]>

* Apply suggestions from code review

Update PR regarding review

Co-authored-by: Alex Kaszynski <[email protected]>

* Update with review comments (local)

* flake8 compliancy

* flake8 compliancy

* class DpfPlotter link added in examples

* Remove "please" mention

* Fix merge issues

* Update example on path (read stresses)

* Update ansys/dpf/core/meshes_container.py

Update with PR review

Co-authored-by: Maxime Rey <[email protected]>

* Update examples with comments (review)

Co-authored-by: Alex Kaszynski <[email protected]>
Co-authored-by: Maxime Rey <[email protected]>

Author: 3 people

ansys/dpf/core/meshes_container.py

@@ -7,6 +7,8 @@
 from ansys import dpf
 from ansys.dpf.core.collection import Collection
 from ansys.dpf.core.common import types
+from ansys.dpf.core.plotter import DpfPlotter
+from ansys.dpf.core import errors as dpf_errors
 
 
 class MeshesContainer(Collection):
@@ -26,7 +28,7 @@ class MeshesContainer(Collection):
 
     def __init__(self, meshes_container=None, server=None):
         """Initialize the scoping with either an optional scoping
-        message or by connecting to a stub."""
+        message or by connecting to a stub. """
         if server is None:
             server = dpf.core._global_server()
 
@@ -37,6 +39,57 @@ def __init__(self, meshes_container=None, server=None):
             self, types.meshed_region, collection=meshes_container, server=self._server
         )
 
+    def plot(self, fields_container=None, **kwargs):
+        """Plot the meshes container with a specific result if
+        fields_container is specified.
+
+        Parameters
+        ----------
+        fields_container : FieldsContainer, optional
+            Data to plot. The default is ``None``.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> from ansys.dpf.core import examples
+        >>> model = dpf.Model(examples.multishells_rst)
+        >>> mesh = model.metadata.meshed_region
+        >>> split_mesh_op = dpf.Operator("split_mesh")
+        >>> split_mesh_op.connect(7, mesh)
+        >>> split_mesh_op.connect(13, "mat")
+        >>> meshes_cont = split_mesh_op.outputs.mesh_controller()
+        >>> disp_op = dpf.Operator("U")
+        >>> disp_op.connect(7, meshes_cont)
+        >>> ds = dpf.DataSources(examples.multishells_rst)
+        >>> disp_op.connect(4, ds)
+        >>> disp_fc = disp_op.outputs.fields_container()
+        >>> meshes_cont.plot(disp_fc)
+
+        """
+        kwargs.setdefault("show_edges", True)
+        notebook = kwargs.pop("notebook", None)
+        pl = DpfPlotter(notebook=notebook)
+        if fields_container is not None:
+            for i in range(len(fields_container)):
+                label_space = fields_container.get_label_space(i)
+                mesh_to_send = self.get_mesh(label_space)
+                if mesh_to_send is None:
+                    raise dpf_errors.DpfValueError(
+                        "Meshes container and result fields "
+                        "container do not have the same scope. "
+                        "Plotting can not proceed. "
+                    )
+                field = fields_container[i]
+                pl.add_field(field, mesh_to_send, **kwargs)
+        else:
+            from random import random
+            random_color = "color" not in kwargs
+            for mesh in self:
+                if random_color:
+                    kwargs["color"] = [random(), random(), random()]
+                pl.add_mesh(mesh, **kwargs)
+        pl.show_figure(**kwargs)
+
     def get_meshes(self, label_space):
         """Retrieve the meshes at a label space.
 

ansys/dpf/core/plotter.py

@@ -15,6 +15,151 @@
 from ansys.dpf.core.check_version import meets_version
 
 
+class _InternalPlotter:
+    def __init__(self, **kwargs):
+        try:
+            import pyvista as pv
+        except ModuleNotFoundError:
+            raise ModuleNotFoundError(
+                "To use plotting capabilities, please install pyvista "
+                "with :\n pip install pyvista>=0.24.0"
+            )
+        mesh = kwargs.pop("mesh", None)
+        self._plotter = pv.Plotter(**kwargs)
+        if mesh is not None:
+            self._plotter.add_mesh(mesh.grid)
+
+    def add_mesh(self, meshed_region, **kwargs):
+        has_attribute_scalar_bar = False
+        try:
+            has_attribute_scalar_bar = hasattr(self._plotter, 'scalar_bar')
+        except:
+            has_attribute_scalar_bar = False
+
+        if not has_attribute_scalar_bar:
+            kwargs.setdefault("stitle", "Mesh")
+        else:
+            if self._plotter.scalar_bar.GetTitle() is None:
+                kwargs.setdefault("stitle", "Mesh")
+        kwargs.setdefault("show_edges", True)
+        kwargs.setdefault("nan_color", "grey")
+        self._plotter.add_mesh(meshed_region.grid, **kwargs)
+
+    def add_field(self, field, meshed_region=None, **kwargs):
+        name = field.name.split("_")[0]
+        kwargs.setdefault("stitle", name)
+        kwargs.setdefault("show_edges", True)
+        kwargs.setdefault("nan_color", "grey")
+
+        # get the meshed region location
+        if meshed_region is None:
+            meshed_region = field.meshed_region
+        location = field.location
+        if location == locations.nodal:
+            mesh_location = meshed_region.nodes
+        elif location == locations.elemental:
+            mesh_location = meshed_region.elements
+        else:
+            raise ValueError(
+                "Only elemental or nodal location are supported for plotting."
+            )
+        component_count = field.component_count
+        if component_count > 1:
+            overall_data = np.full((len(mesh_location), component_count), np.nan)
+        else:
+            overall_data = np.full(len(mesh_location), np.nan)
+        ind, mask = mesh_location.map_scoping(field.scoping)
+        overall_data[ind] = field.data[mask]
+
+        # plot
+        self._plotter.add_mesh(meshed_region.grid, scalars=overall_data, **kwargs)
+
+    def show_figure(self, **kwargs):
+        background = kwargs.pop("background", None)
+        if background is not None:
+            self._plotter.set_background(background)
+
+        # show result
+        show_axes = kwargs.pop("show_axes", None)
+        if show_axes:
+            self._plotter.add_axes()
+        return self._plotter.show()
+
+
+class DpfPlotter:
+    def __init__(self, **kwargs):
+        self._internal_plotter = _InternalPlotter(**kwargs)
+
+    def add_mesh(self, meshed_region, **kwargs):
+        """Add a mesh to plot.
+
+        Parameters
+        ----------
+        meshed_region : MeshedRegion
+            MeshedRegion to plot.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> from ansys.dpf.core import examples
+        >>> model = dpf.Model(examples.multishells_rst)
+        >>> mesh = model.metadata.meshed_region
+        >>> from ansys.dpf.core.plotter import DpfPlotter
+        >>> pl = DpfPlotter()
+        >>> pl.add_mesh(mesh)
+
+        """
+        self._internal_plotter.add_mesh(meshed_region=meshed_region, **kwargs)
+
+    def add_field(self, field, meshed_region=None, **kwargs):
+        """Add a field containing data to the plotter.
+
+        A meshed_region to plot on can be added.
+        If no ``meshed_region`` is specified, the field
+        support will be used. Ensure that the field
+        support is a ``meshed_region``.
+
+        Parameters
+        ----------
+        field : Field
+            Field data to plot
+        meshed_region : MeshedRegion, optional
+            ``MeshedRegion`` to plot the field on.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> from ansys.dpf.core import examples
+        >>> model = dpf.Model(examples.multishells_rst)
+        >>> mesh = model.metadata.meshed_region
+        >>> field = model.results.displacement().outputs.fields_container()[0]
+        >>> from ansys.dpf.core.plotter import DpfPlotter
+        >>> pl = DpfPlotter()
+        >>> pl.add_field(field, mesh)
+
+        """
+        self._internal_plotter.add_field(field=field,
+                                         meshed_region=meshed_region,
+                                         **kwargs)
+
+    def show_figure(self, **kwargs):
+        """Plot the figure built by the plotter object.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> from ansys.dpf.core import examples
+        >>> model = dpf.Model(examples.multishells_rst)
+        >>> mesh = model.metadata.meshed_region
+        >>> field = model.results.displacement().outputs.fields_container()[0]
+        >>> from ansys.dpf.core.plotter import DpfPlotter
+        >>> pl = DpfPlotter()
+        >>> pl.add_field(field, mesh)
+        >>> pl.show_figure()
+
+        """
+        self._internal_plotter.show_figure(**kwargs)
+
 def plot_chart(fields_container):
     """Plot the minimum/maximum result values over time.
 
@@ -51,7 +196,8 @@ class Plotter:
 
     """
 
-    def __init__(self, mesh):
+    def __init__(self, mesh, **kwargs):
+        self._internal_plotter = _InternalPlotter(mesh=mesh, **kwargs)
         self._mesh = mesh
 
     def plot_mesh(self, **kwargs):
@@ -140,6 +286,7 @@ def plot_contour(
         shell_layers=None,
         off_screen=None,
         show_axes=True,
+        meshed_region=None,
         **kwargs
     ):
         """Plot the contour result on its mesh support.
@@ -202,7 +349,10 @@ def plot_contour(
                 if label[DefinitionLabels.time] != first_time:
                     raise dpf_errors.FieldContainerPlottingError
 
-        mesh = self._mesh
+        if meshed_region is not None:
+            mesh = meshed_region
+        else:
+            mesh = self._mesh
 
         # get mesh scoping
         location = None
@@ -261,41 +411,39 @@ def plot_contour(
         cpos = kwargs.pop("cpos", None)
         return_cpos = kwargs.pop("return_cpos", None)
 
-        try:
-            import pyvista as pv
-        except ModuleNotFoundError:
-            raise ModuleNotFoundError(
-                "To use plotting capabilities, please install pyvista "
-                "with :\n pip install pyvista>=0.24.0"
-            )
-        plotter = pv.Plotter(notebook=notebook, off_screen=off_screen)
+        # plotter = pv.Plotter(notebook=notebook, off_screen=off_screen)
+        if notebook is not None:
+            self._internal_plotter._plotter.notebook = notebook
+        if off_screen is not None:
+            self._internal_plotter._plotter.off_screen = off_screen
 
         # add meshes
         kwargs.setdefault("show_edges", True)
         kwargs.setdefault("nan_color", "grey")
         kwargs.setdefault("stitle", name)
         text = kwargs.pop('text', None)
         if text is not None:
-            plotter.add_text(text, position='lower_edge')
-        plotter.add_mesh(mesh.grid, scalars=overall_data, **kwargs)
+            self._internal_plotter._plotter.add_text(text, position='lower_edge')
+        self._internal_plotter._plotter.add_mesh(mesh.grid, scalars=overall_data, **kwargs)
 
         if background is not None:
-            plotter.set_background(background)
+            self._internal_plotter._plotter.set_background(background)
 
         if cpos is not None:
-            plotter.camera_position = cpos
+            self._internal_plotter._plotter.camera_position = cpos
 
         # show result
         if show_axes:
-            plotter.add_axes()
+            self._internal_plotter._plotter.add_axes()
         if return_cpos is None:
-            return plotter.show()
+            return self._internal_plotter._plotter.show()
         else:
+            import pyvista as pv
             pv_version = pv.__version__
             version_to_reach = '0.32.0'
             meet_ver = meets_version(pv_version, version_to_reach)
             if meet_ver:
-                return plotter.show(return_cpos=return_cpos)
+                return self._internal_plotter._plotter.show(return_cpos=return_cpos)
             else:
                 txt = """To use the return_cpos option, please upgrade
                 your pyvista module with a version higher than """

examples/05-plotting/00-plot_on_path.py

@@ -0,0 +1,63 @@
+"""
+.. _plot_on_path:
+
+Plot results on a specific path
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This example shows how to get a result mapped over a specific path,
+and how to plot it.
+
+"""
+
+from ansys.dpf import core as dpf
+from ansys.dpf.core import examples
+from ansys.dpf.core.plotter import DpfPlotter
+
+###############################################################################
+# Path plotting
+# ~~~~~~~~~~~~~
+# We will use an :class:`ansys.dpf.core.plotter.DpfPlotter` to plot a mapped result over
+# a defined path of coordinates.
+
+# First, we need to create the model, request its mesh and its
+# displacement data
+model = dpf.Model(examples.static_rst)
+mesh = model.metadata.meshed_region
+stress_fc = model.results.stress().eqv().outputs.fields_container()
+
+###############################################################################
+# Then, we create a coordinates field to map on
+coordinates = []
+ref = [0.024, 0.03, 0.003]
+coordinates.append(ref)
+for i in range(1, 51):
+    coord_copy = ref.copy()
+    coord_copy[1] = coord_copy[0] + i * 0.001
+    coordinates.append(coord_copy)
+field_coord = dpf.fields_factory.create_3d_vector_field(len(coordinates))
+field_coord.data = coordinates
+field_coord.scoping.ids = list(range(1, len(coordinates) + 1))
+
+###############################################################################
+# Let's now compute the mapped data using the mapping operator
+mapping_operator = dpf.Operator("mapping")
+mapping_operator.inputs.fields_container.connect(stress_fc)
+mapping_operator.inputs.coordinates.connect(field_coord)
+mapping_operator.inputs.mesh.connect(mesh)
+mapping_operator.inputs.create_support.connect(True)
+fields_mapped = mapping_operator.outputs.fields_container()
+
+###############################################################################
+# Here, we request the mapped field data and its mesh
+field_m = fields_mapped[0]
+mesh_m = field_m.meshed_region
+
+###############################################################################
+# Now we create the plotter and add fields and meshes
+pl = DpfPlotter()
+
+pl.add_field(field_m, mesh_m)
+pl.add_mesh(mesh, style="surface", show_edges=True,
+             color="w", opacity=0.3)
+
+# Finally we plot the result
+pl.show_figure(show_axes=True)