update generated code

Author: PProfizi

doc/source/_static/dpf_operators.html

@@ -27,7 +27,8 @@ class min_max_over_time(Operator):
 
     Returns
     -------
-    fields_container: FieldsContainer
+    field_container_1: FieldsContainer
+    field_container_2: FieldsContainer, optional
 
     Examples
     --------
@@ -49,7 +50,8 @@ class min_max_over_time(Operator):
     ... )
 
     >>> # Get output data
-    >>> result_fields_container = op.outputs.fields_container()
+    >>> result_field_container_1 = op.outputs.field_container_1()
+    >>> result_field_container_2 = op.outputs.field_container_2()
     """
 
     def __init__(self, fields_container=None, int32=None, config=None, server=None):
@@ -85,11 +87,17 @@ def _spec() -> Specification:
             },
             map_output_pin_spec={
                 0: PinSpecification(
-                    name="fields_container",
+                    name="field_container_1",
                     type_names=["fields_container"],
                     optional=False,
                     document=r"""""",
                 ),
+                1: PinSpecification(
+                    name="field_container_2",
+                    type_names=["fields_container"],
+                    optional=True,
+                    document=r"""""",
+                ),
             },
         )
         return spec
@@ -213,17 +221,20 @@ class OutputsMinMaxOverTime(_Outputs):
     >>> from ansys.dpf import core as dpf
     >>> op = dpf.operators.math.min_max_over_time()
     >>> # Connect inputs : op.inputs. ...
-    >>> result_fields_container = op.outputs.fields_container()
+    >>> result_field_container_1 = op.outputs.field_container_1()
+    >>> result_field_container_2 = op.outputs.field_container_2()
     """
 
     def __init__(self, op: Operator):
         super().__init__(min_max_over_time._spec().outputs, op)
-        self._fields_container = Output(min_max_over_time._spec().output_pin(0), 0, op)
-        self._outputs.append(self._fields_container)
+        self._field_container_1 = Output(min_max_over_time._spec().output_pin(0), 0, op)
+        self._outputs.append(self._field_container_1)
+        self._field_container_2 = Output(min_max_over_time._spec().output_pin(1), 1, op)
+        self._outputs.append(self._field_container_2)
 
     @property
-    def fields_container(self) -> Output:
-        r"""Allows to get fields_container output of the operator
+    def field_container_1(self) -> Output:
+        r"""Allows to get field_container_1 output of the operator
 
         Returns
         -------
@@ -235,6 +246,24 @@ def fields_container(self) -> Output:
         >>> from ansys.dpf import core as dpf
         >>> op = dpf.operators.math.min_max_over_time()
         >>> # Get the output from op.outputs. ...
-        >>> result_fields_container = op.outputs.fields_container()
+        >>> result_field_container_1 = op.outputs.field_container_1()
         """
-        return self._fields_container
+        return self._field_container_1
+
+    @property
+    def field_container_2(self) -> Output:
+        r"""Allows to get field_container_2 output of the operator
+
+        Returns
+        -------
+        output:
+            An Output instance for this pin.
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.math.min_max_over_time()
+        >>> # Get the output from op.outputs. ...
+        >>> result_field_container_2 = op.outputs.field_container_2()
+        """
+        return self._field_container_2

src/ansys/dpf/core/operators/math/min_max_over_time.py

@@ -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