update generated code

Author: PProfizi

doc/source/_static/dpf_operators.html

@@ -33,6 +33,10 @@ class from_scoping(Operator):
     nodes_only: bool, optional
         returns mesh with nodes only (without any elements or property fields). Default is false.
     mesh: MeshedRegion
+    already_fill_map: bool
+        internal pin used when running meshes::by_scopings operator to never recalculate heavy map over scopings. Default is false.
+    keep_map: bool
+        internal pin used to keep cached map if necessary. Default is false.
 
     Returns
     -------
@@ -54,13 +58,19 @@ class from_scoping(Operator):
     >>> op.inputs.nodes_only.connect(my_nodes_only)
     >>> my_mesh = dpf.MeshedRegion()
     >>> op.inputs.mesh.connect(my_mesh)
+    >>> my_already_fill_map = bool()
+    >>> op.inputs.already_fill_map.connect(my_already_fill_map)
+    >>> my_keep_map = bool()
+    >>> op.inputs.keep_map.connect(my_keep_map)
 
     >>> # Instantiate operator and connect inputs in one line
     >>> op = dpf.operators.mesh.from_scoping(
     ...     scoping=my_scoping,
     ...     inclusive=my_inclusive,
     ...     nodes_only=my_nodes_only,
     ...     mesh=my_mesh,
+    ...     already_fill_map=my_already_fill_map,
+    ...     keep_map=my_keep_map,
     ... )
 
     >>> # Get output data
@@ -73,6 +83,8 @@ def __init__(
         inclusive=None,
         nodes_only=None,
         mesh=None,
+        already_fill_map=None,
+        keep_map=None,
         config=None,
         server=None,
     ):
@@ -87,6 +99,10 @@ def __init__(
             self.inputs.nodes_only.connect(nodes_only)
         if mesh is not None:
             self.inputs.mesh.connect(mesh)
+        if already_fill_map is not None:
+            self.inputs.already_fill_map.connect(already_fill_map)
+        if keep_map is not None:
+            self.inputs.keep_map.connect(keep_map)
 
     @staticmethod
     def _spec() -> Specification:
@@ -124,6 +140,18 @@ def _spec() -> Specification:
                     optional=False,
                     document=r"""""",
                 ),
+                200: PinSpecification(
+                    name="already_fill_map",
+                    type_names=["bool"],
+                    optional=False,
+                    document=r"""internal pin used when running meshes::by_scopings operator to never recalculate heavy map over scopings. Default is false.""",
+                ),
+                201: PinSpecification(
+                    name="keep_map",
+                    type_names=["bool"],
+                    optional=False,
+                    document=r"""internal pin used to keep cached map if necessary. Default is false.""",
+                ),
             },
             map_output_pin_spec={
                 0: PinSpecification(
@@ -196,6 +224,10 @@ class InputsFromScoping(_Inputs):
     >>> op.inputs.nodes_only.connect(my_nodes_only)
     >>> my_mesh = dpf.MeshedRegion()
     >>> op.inputs.mesh.connect(my_mesh)
+    >>> my_already_fill_map = bool()
+    >>> op.inputs.already_fill_map.connect(my_already_fill_map)
+    >>> my_keep_map = bool()
+    >>> op.inputs.keep_map.connect(my_keep_map)
     """
 
     def __init__(self, op: Operator):
@@ -208,6 +240,10 @@ def __init__(self, op: Operator):
         self._inputs.append(self._nodes_only)
         self._mesh = Input(from_scoping._spec().input_pin(7), 7, op, -1)
         self._inputs.append(self._mesh)
+        self._already_fill_map = Input(from_scoping._spec().input_pin(200), 200, op, -1)
+        self._inputs.append(self._already_fill_map)
+        self._keep_map = Input(from_scoping._spec().input_pin(201), 201, op, -1)
+        self._inputs.append(self._keep_map)
 
     @property
     def scoping(self) -> Input:
@@ -291,6 +327,48 @@ def mesh(self) -> Input:
         """
         return self._mesh
 
+    @property
+    def already_fill_map(self) -> Input:
+        r"""Allows to connect already_fill_map input to the operator.
+
+        internal pin used when running meshes::by_scopings operator to never recalculate heavy map over scopings. Default is false.
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.mesh.from_scoping()
+        >>> op.inputs.already_fill_map.connect(my_already_fill_map)
+        >>> # or
+        >>> op.inputs.already_fill_map(my_already_fill_map)
+        """
+        return self._already_fill_map
+
+    @property
+    def keep_map(self) -> Input:
+        r"""Allows to connect keep_map input to the operator.
+
+        internal pin used to keep cached map if necessary. Default is false.
+
+        Returns
+        -------
+        input:
+            An Input instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.mesh.from_scoping()
+        >>> op.inputs.keep_map.connect(my_keep_map)
+        >>> # or
+        >>> op.inputs.keep_map(my_keep_map)
+        """
+        return self._keep_map
+
 
 class OutputsFromScoping(_Outputs):
     """Intermediate class used to get outputs from

src/ansys/dpf/core/operators/mesh/from_scoping.py

@@ -18,6 +18,7 @@
 from .extract_time_freq import extract_time_freq
 from .fc_get_attribute import fc_get_attribute
 from .field import field
+from .field_clone_to_shell_layer import field_clone_to_shell_layer
 from .field_get_attribute import field_get_attribute
 from .field_to_fc import field_to_fc
 from .fields_container import fields_container

src/ansys/dpf/core/operators/utility/__init__.py

@@ -34,7 +34,7 @@ class change_shell_layers(Operator):
     mesh: MeshedRegion or MeshesContainer, optional
         Mesh support of the input fields_container, in case it does not have one defined. If the fields_container contains mixed shell/solid results, the mesh is required (either by connecting this pin or in the support).
     merge: bool, optional
-        For shell/solid mixed fields, group in the same field all solids and shells (false by default).
+        For fields with mixed shell layers (solid/shell elements with heterogeneous shell layers), group all of them in the same field (false by default).
 
     Returns
     -------
@@ -125,7 +125,7 @@ def _spec() -> Specification:
                     name="merge",
                     type_names=["bool"],
                     optional=True,
-                    document=r"""For shell/solid mixed fields, group in the same field all solids and shells (false by default).""",
+                    document=r"""For fields with mixed shell layers (solid/shell elements with heterogeneous shell layers), group all of them in the same field (false by default).""",
                 ),
             },
             map_output_pin_spec={
@@ -279,7 +279,7 @@ def mesh(self) -> Input:
     def merge(self) -> Input:
         r"""Allows to connect merge input to the operator.
 
-        For shell/solid mixed fields, group in the same field all solids and shells (false by default).
+        For fields with mixed shell layers (solid/shell elements with heterogeneous shell layers), group all of them in the same field (false by default).
 
         Returns
         -------