Plot fixes, operators helpers updated (#11)

Author: anslpa

.gitignore

@@ -12,6 +12,9 @@
 #ansys/dpf/core
 /ansys/dpf/core/__pycache__
 
+#operators
+/ansys/dpf/core/operators/__pycache__
+
 #other
 /perso
 /examples/.ipynb_checkpoints

ansys/dpf/core/__init__.py

@@ -23,10 +23,10 @@
                                    _global_channel, connect_to_server)
 from ansys.dpf.core.data_sources import DataSources
 from ansys.dpf.core.scoping import Scoping
-from ansys.dpf.core.common import types, natures, field_from_array, locations
+from ansys.dpf.core.common import types, natures, field_from_array, locations, ShellLayers
 from ansys.dpf.core.core import BaseService
 from ansys.dpf.core.time_freq_support import TimeFreqSupport
-from ansys.dpf.core.operators import sum, to_nodal, norm, eqv
+from ansys.dpf.core.operators_helper import sum, to_nodal, norm, eqv
 from ansys.dpf.core.meshed_region import MeshedRegion
 from ansys.dpf.core.result_info import ResultInfo
 from ansys.dpf.core.collection import Collection

ansys/dpf/core/common.py

@@ -58,7 +58,17 @@ class locations:
 
     #applies everywhere
     overall = "overall"
-
+    
+    
+class ShellLayers(Enum):
+    """Contains shell layers types."""
+    TOP = 0
+    BOTTOM = 1
+    TOPBOTTOM = 2
+    MID = 3
+    TOPBOTTOMMID = 4
+    NONELAYER = 5
+    INDEPENDANTLAYER = 6
 
 
 def field_from_array(arr):

ansys/dpf/core/dpf_operator.py

@@ -6,7 +6,7 @@
 from ansys.grpc.dpf import operator_pb2, operator_pb2_grpc, base_pb2
 from ansys.dpf.core import (fields_container, field, scoping,
                             meshed_region, result_info, time_freq_support,
-                            operators, collection, data_sources, server)
+                            operators_helper, collection, data_sources, server)
 from ansys.dpf.core.common import types, camel_to_snake_case
 from ansys.dpf.core.inputs import Inputs
 from ansys.dpf.core.outputs import Outputs

ansys/dpf/core/field.py

@@ -4,9 +4,9 @@
 
 from ansys import dpf
 from ansys.grpc.dpf import field_pb2, field_pb2_grpc, base_pb2, field_definition_pb2, field_definition_pb2_grpc
-from ansys.dpf.core.common import natures, types, locations
-from ansys.dpf.core import operators, plotting, scoping, meshed_region, time_freq_support
-
+from ansys.dpf.core.common import natures, types, locations, ShellLayers
+from ansys.dpf.core import operators_helper, scoping, meshed_region, time_freq_support
+from ansys.dpf.core.plotter import Plotter
 
 class Field:
     """Class representing evaluated data from a ``ansys.dpf.core.Operator``.
@@ -74,9 +74,10 @@ def __init__(self, nentities=0,
                 raise TypeError(f'Cannot create a field from a "{type(field)}" object')
 
         self._field_definition = self._load_field_definition()
-
+        
         # add dynamic methods
         self._update_dynamic_methods()
+        
 
     @property
     def size(self):
@@ -98,38 +99,12 @@ def elementary_data_shape(self):
             return (1, self.component_count)
         else :
             return self.component_count
-
+        
     def _update_dynamic_methods(self):
         """Add or remove dynamic methods to this instance based on the
         field type"""
         if self.location in [locations.elemental_nodal, locations.elemental]:
             self.to_nodal = self.__to_nodal
-        
-        # specify plot method based on field type
-        if self.location ==  locations.elemental:
-            self.plot = self.__plot_elemental
-        elif self.location in [locations.nodal, locations.elemental_nodal]:
-            self.plot = self.__plot_nodal
-            self.plot = self.__plot_lines
-       
-
-    @wraps(plotting.plot_lines)
-    def __plot_lines(self, *args, **kwargs):
-        """Wraps plotting.plot_lines"""
-        return plotting.plot_lines(self, *args, **kwargs)
-
-    @wraps(plotting.plot_nodal)
-    def __plot_nodal(self, comp=None, **kwargs):
-        """wraps plotting.plot_nodal"""
-        return plotting.plot_nodal(self, comp, **kwargs)
-
-    @wraps(plotting.plot_elemental)
-    def __plot_elemental(self, comp=None, **kwargs):
-        """wraps plotting.plot_elemental
-
-        Should be only available when type == locations.elemental
-        """
-        return plotting.plot_elemental(self, comp, **kwargs)
 
     @property
     def location(self):
@@ -142,12 +117,46 @@ def location(self):
         if self._field_definition:
             return self._field_definition.location
 
+    @property
+    def shell_layers(self):
+        """Return the field shell layers.
+        
+        Returns
+        -------
+        Enum 
+            dpf.core.common.ShellLayers enum value
+        """
+        if self._field_definition:
+            return self._field_definition.shell_layers
+        
     def __to_nodal(self):
         """create a to_nodal operator and evaluates it"""
         op = dpf.core.Operator("to_nodal")
         op.inputs.connect(self)
         return op.outputs.field()
 
+    def plot(self, notebook = None, shell_layers = None):
+        """Plot the field/fields container on mesh support if exists.
+        
+        Warning
+        -------
+        Regarding the interactions with the GRPc server, this can be slower than:
+        >>> mesh = model.metadata.meshed_region
+        >>> mesh.plot(field)
+        Better use the previous lines.  
+        
+        Parameters
+        ----------         
+        notebook (default: True)
+            bool, that specifies if the plotting is in the notebook (2D) or not (3D)
+            
+        shell_layers : core.ShellLayers, optional
+            Enum used to set the shell layers if the model to plot 
+            contains shell elements.
+        """
+        pl = Plotter(self.meshed_region)
+        pl.plot_contour(self, notebook, shell_layers)
+    
     def resize(self, nentities, datasize):
         """allocate memory
 
@@ -392,12 +401,12 @@ def component_count(self):
 
     def __add__(self, field_b):
         """Adds two fields together"""
-        return dpf.core.operators.add(self, field_b)
+        return dpf.core.operators_helper.add(self, field_b)
 
     def __pow__(self, value):
         if value != 2:
             raise ValueError('DPF only the value is "2" suppported')
-        return dpf.core.operators.sqr(self)
+        return dpf.core.operators_helper.sqr(self)
 
     def _del_data(self):
         pass
@@ -442,9 +451,9 @@ def __len__(self):
         return self.size
 
 
-    @wraps(operators.min_max)
+    @wraps(operators_helper.min_max)
     def _min_max(self):
-        return operators.min_max(self)
+        return operators_helper.min_max(self)
 
     def min(self):
         """Component-wise minimum over this field
@@ -487,6 +496,11 @@ def location(self):
     @property
     def unit(self):
         return self._stub.List(self._messageDefinition).unit.symbol
+    
+    @property
+    def shell_layers(self):
+        enum_val = self._stub.List(self._messageDefinition).shell_layers
+        return ShellLayers(enum_val)
 
     def __del__(self):
         try:

ansys/dpf/core/meshed_region.py

@@ -172,30 +172,26 @@ def grid(self):
             self._full_grid = self._as_vtk()
         return self._full_grid
 
-    def plot(self, field_or_fields_container=None, is3dplotting=False):
+    def plot(self, field_or_fields_container=None, notebook=None, shell_layers=None):
         """Plot the field/fields container on mesh.
         
         Parameters
         ----------
         field_or_fields_container
             dpf.core.Field or dpf.core.FieldsContainer
             
-        is3dplotting (default: False)
-            bool, that specifies if the plotting is 3D or not
+        notebook (default: None)
+            bool, that specifies if the plotting is in the notebook (2D) or not (3D)
+            
+        shell_layers : core.ShellLayers, optional
+            Enum used to set the shell layers if the model to plot 
+            contains shell elements.
         """
         pl = _DpfPlotter(self)
-        if isinstance(field_or_fields_container, dpf.core.Field) or isinstance(field_or_fields_container, dpf.core.FieldsContainer):
-            fields_container = None
-            if isinstance(field_or_fields_container, dpf.core.Field):
-                fields_container = dpf.core.FieldsContainer()
-                fields_container.add_label('time')
-                fields_container.add_field({'time':1}, field_or_fields_container)
-            elif isinstance(field_or_fields_container, dpf.core.FieldsContainer):
-                fields_container = field_or_fields_container
-            pl.plot_contour(fields_container, not is3dplotting)
-        elif(field_or_fields_container is None):
-            pl.plot_mesh(not is3dplotting)
-
+        if field_or_fields_container is not None:
+            pl.plot_contour(field_or_fields_container, notebook, shell_layers)
+        else:
+            pl.plot_mesh(notebook)
 
 
 class Node:
@@ -303,9 +299,9 @@ def _get_element_shape(self):
 
 class Nodes():
     """Class to encapsulate mesh nodes"""
-
     def __init__(self, mesh):
         self._mesh = mesh
+        self._mapping_id_to_index = None
 
     def __str__(self):
         return 'DPF Nodes object with %d nodes\n' % len(self)
@@ -389,13 +385,31 @@ def _get_coordinates_field(self):
         request.nodal_property = meshed_region_pb2.COORDINATES
         fieldOut = self._mesh._stub.ListProperty(request)
         return field.Field(self._mesh._channel, field=fieldOut)
+    
+    
+    def _build_mapping_id_to_index(self):
+        """Return a mapping between ids and indeces of the entity."""
+        dic_out = {}
+        ids = self._mesh.nodes.scoping.ids
+        i = 0
+        for node_id in ids:
+            dic_out[node_id] = i
+            i += 1
+        return dic_out
+        
+    @property
+    def mapping_id_to_index(self):
+        if self._mapping_id_to_index is None:
+            self._mapping_id_to_index = self._build_mapping_id_to_index()
+        return self._mapping_id_to_index
 
 
 class Elements():
     """Class to encapsulate mesh elements"""
-
+    
     def __init__(self, mesh):
         self._mesh = mesh
+        self._mapping_id_to_index = None
 
     def __str__(self):
         return 'DPF Elements object with %d elements' % len(self)
@@ -523,10 +537,25 @@ def _get_connectivities_field(self):
         request.elemental_property = meshed_region_pb2.CONNECTIVITY
         fieldOut = self._mesh._stub.ListProperty(request)
         return field.Field(self._mesh._channel, field=fieldOut)
-    
 
     @property
     def n_elements(self):
         """Number of elements"""
         return self.scoping.size
+    
+    def _build_mapping_id_to_index(self):
+        """Return a mapping between ids and indeces of the entity."""
+        dic_out = {}
+        ids = self._mesh.elements.scoping.ids
+        i = 0
+        for element_id in ids:
+            dic_out[element_id] = i
+            i += 1
+        return dic_out
+        
+    @property
+    def mapping_id_to_index(self):
+        if self._mapping_id_to_index is None:
+            self._mapping_id_to_index = self._build_mapping_id_to_index()
+        return self._mapping_id_to_index