update generated code (#1498)

Author: pyansys-ci-bot

doc/source/_static/dpf_operators.html

@@ -27,16 +27,22 @@ class fft(Operator):
     field : Field or FieldsContainer
         Field or fields container.
     scale_forward_transform : float, optional
-        Scale for forward transform, default is 1.0.
+        Scale for forward transform, default is
+        2/field_num_elementary_data.
     inplace : bool, optional
         True if inplace, default is false.
     force_fft_points : int, optional
         Explicitely define number of fft points to
         either rescope or perform zero
         padding.
     cutoff_frequency : float, optional
-        Restrict output frequency output up to this
-        cutoff frequency
+        Restrict output frequency up to this cutoff
+        frequency
+    scale_right_amplitude : bool, optional
+        If set to true (default is false),
+        2/field_num_entities scaling will be
+        applied, to have right amplitude
+        values.
 
 
     Examples
@@ -57,6 +63,8 @@ class fft(Operator):
     >>> op.inputs.force_fft_points.connect(my_force_fft_points)
     >>> my_cutoff_frequency = float()
     >>> op.inputs.cutoff_frequency.connect(my_cutoff_frequency)
+    >>> my_scale_right_amplitude = bool()
+    >>> op.inputs.scale_right_amplitude.connect(my_scale_right_amplitude)
 
     >>> # Instantiate operator and connect inputs in one line
     >>> op = dpf.operators.mapping.fft(
@@ -65,6 +73,7 @@ class fft(Operator):
     ...     inplace=my_inplace,
     ...     force_fft_points=my_force_fft_points,
     ...     cutoff_frequency=my_cutoff_frequency,
+    ...     scale_right_amplitude=my_scale_right_amplitude,
     ... )
 
     >>> # Get output data
@@ -78,6 +87,7 @@ def __init__(
         inplace=None,
         force_fft_points=None,
         cutoff_frequency=None,
+        scale_right_amplitude=None,
         config=None,
         server=None,
     ):
@@ -94,6 +104,8 @@ def __init__(
             self.inputs.force_fft_points.connect(force_fft_points)
         if cutoff_frequency is not None:
             self.inputs.cutoff_frequency.connect(cutoff_frequency)
+        if scale_right_amplitude is not None:
+            self.inputs.scale_right_amplitude.connect(scale_right_amplitude)
 
     @staticmethod
     def _spec():
@@ -120,7 +132,8 @@ def _spec():
                     name="scale_forward_transform",
                     type_names=["double"],
                     optional=True,
-                    document="""Scale for forward transform, default is 1.0.""",
+                    document="""Scale for forward transform, default is
+        2/field_num_elementary_data.""",
                 ),
                 4: PinSpecification(
                     name="inplace",
@@ -140,8 +153,17 @@ def _spec():
                     name="cutoff_frequency",
                     type_names=["double"],
                     optional=True,
-                    document="""Restrict output frequency output up to this
-        cutoff frequency""",
+                    document="""Restrict output frequency up to this cutoff
+        frequency""",
+                ),
+                7: PinSpecification(
+                    name="scale_right_amplitude",
+                    type_names=["bool"],
+                    optional=True,
+                    document="""If set to true (default is false),
+        2/field_num_entities scaling will be
+        applied, to have right amplitude
+        values.""",
                 ),
             },
             map_output_pin_spec={
@@ -213,6 +235,8 @@ class InputsFft(_Inputs):
     >>> op.inputs.force_fft_points.connect(my_force_fft_points)
     >>> my_cutoff_frequency = float()
     >>> op.inputs.cutoff_frequency.connect(my_cutoff_frequency)
+    >>> my_scale_right_amplitude = bool()
+    >>> op.inputs.scale_right_amplitude.connect(my_scale_right_amplitude)
     """
 
     def __init__(self, op: Operator):
@@ -227,6 +251,8 @@ def __init__(self, op: Operator):
         self._inputs.append(self._force_fft_points)
         self._cutoff_frequency = Input(fft._spec().input_pin(6), 6, op, -1)
         self._inputs.append(self._cutoff_frequency)
+        self._scale_right_amplitude = Input(fft._spec().input_pin(7), 7, op, -1)
+        self._inputs.append(self._scale_right_amplitude)
 
     @property
     def field(self):
@@ -252,7 +278,8 @@ def field(self):
     def scale_forward_transform(self):
         """Allows to connect scale_forward_transform input to the operator.
 
-        Scale for forward transform, default is 1.0.
+        Scale for forward transform, default is
+        2/field_num_elementary_data.
 
         Parameters
         ----------
@@ -314,8 +341,8 @@ def force_fft_points(self):
     def cutoff_frequency(self):
         """Allows to connect cutoff_frequency input to the operator.
 
-        Restrict output frequency output up to this
-        cutoff frequency
+        Restrict output frequency up to this cutoff
+        frequency
 
         Parameters
         ----------
@@ -331,6 +358,29 @@ def cutoff_frequency(self):
         """
         return self._cutoff_frequency
 
+    @property
+    def scale_right_amplitude(self):
+        """Allows to connect scale_right_amplitude input to the operator.
+
+        If set to true (default is false),
+        2/field_num_entities scaling will be
+        applied, to have right amplitude
+        values.
+
+        Parameters
+        ----------
+        my_scale_right_amplitude : bool
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.mapping.fft()
+        >>> op.inputs.scale_right_amplitude.connect(my_scale_right_amplitude)
+        >>> # or
+        >>> op.inputs.scale_right_amplitude(my_scale_right_amplitude)
+        """
+        return self._scale_right_amplitude
+
 
 class OutputsFft(_Outputs):
     """Intermediate class used to get outputs from

src/ansys/dpf/core/operators/mapping/fft.py

@@ -46,6 +46,10 @@ class compute_residual_and_error(Operator):
         pin2 selection
         1 for l1, ie sum(abs(xi)),
         2 for l2, ie sqrt(sum((xi^2))
+    field_reference : int, optional
+        Field reference for the normalization step,
+        default: 0 for entry 1, 1 for
+        residuals - optional
     field_or_fields_container2 : Field or FieldsContainer, optional
         Field or fields container of same
         dimensionality as entry 1 - optional
@@ -65,6 +69,8 @@ class compute_residual_and_error(Operator):
     >>> op.inputs.normalization_type.connect(my_normalization_type)
     >>> my_norm_calculation_type = int()
     >>> op.inputs.norm_calculation_type.connect(my_norm_calculation_type)
+    >>> my_field_reference = int()
+    >>> op.inputs.field_reference.connect(my_field_reference)
     >>> my_field_or_fields_container2 = dpf.Field()
     >>> op.inputs.field_or_fields_container2.connect(my_field_or_fields_container2)
 
@@ -73,19 +79,23 @@ class compute_residual_and_error(Operator):
     ...     field_or_fields_container1=my_field_or_fields_container1,
     ...     normalization_type=my_normalization_type,
     ...     norm_calculation_type=my_norm_calculation_type,
+    ...     field_reference=my_field_reference,
     ...     field_or_fields_container2=my_field_or_fields_container2,
     ... )
 
     >>> # Get output data
     >>> result_residuals = op.outputs.residuals()
     >>> result_error = op.outputs.error()
+    >>> result_residuals_normalization_factor = op.outputs.residuals_normalization_factor()
+    >>> result_error_normalization_factor = op.outputs.error_normalization_factor()
     """
 
     def __init__(
         self,
         field_or_fields_container1=None,
         normalization_type=None,
         norm_calculation_type=None,
+        field_reference=None,
         field_or_fields_container2=None,
         config=None,
         server=None,
@@ -99,6 +109,8 @@ def __init__(
             self.inputs.normalization_type.connect(normalization_type)
         if norm_calculation_type is not None:
             self.inputs.norm_calculation_type.connect(norm_calculation_type)
+        if field_reference is not None:
+            self.inputs.field_reference.connect(field_reference)
         if field_or_fields_container2 is not None:
             self.inputs.field_or_fields_container2.connect(field_or_fields_container2)
 
@@ -151,6 +163,14 @@ def _spec():
         2 for l2, ie sqrt(sum((xi^2))""",
                 ),
                 3: PinSpecification(
+                    name="field_reference",
+                    type_names=["int32"],
+                    optional=True,
+                    document="""Field reference for the normalization step,
+        default: 0 for entry 1, 1 for
+        residuals - optional""",
+                ),
+                4: PinSpecification(
                     name="field_or_fields_container2",
                     type_names=["field", "fields_container"],
                     optional=True,
@@ -175,6 +195,18 @@ def _spec():
                     document="""1: error as a field or a field container
         depending on the entry's type.""",
                 ),
+                2: PinSpecification(
+                    name="residuals_normalization_factor",
+                    type_names=["field", "fields_container"],
+                    optional=False,
+                    document="""2: factor used for residual normalization""",
+                ),
+                3: PinSpecification(
+                    name="error_normalization_factor",
+                    type_names=["field", "fields_container"],
+                    optional=False,
+                    document="""3: factor used for error norm normalization""",
+                ),
             },
         )
         return spec
@@ -230,6 +262,8 @@ class InputsComputeResidualAndError(_Inputs):
     >>> op.inputs.normalization_type.connect(my_normalization_type)
     >>> my_norm_calculation_type = int()
     >>> op.inputs.norm_calculation_type.connect(my_norm_calculation_type)
+    >>> my_field_reference = int()
+    >>> op.inputs.field_reference.connect(my_field_reference)
     >>> my_field_or_fields_container2 = dpf.Field()
     >>> op.inputs.field_or_fields_container2.connect(my_field_or_fields_container2)
     """
@@ -248,9 +282,13 @@ def __init__(self, op: Operator):
             compute_residual_and_error._spec().input_pin(2), 2, op, -1
         )
         self._inputs.append(self._norm_calculation_type)
-        self._field_or_fields_container2 = Input(
+        self._field_reference = Input(
             compute_residual_and_error._spec().input_pin(3), 3, op, -1
         )
+        self._inputs.append(self._field_reference)
+        self._field_or_fields_container2 = Input(
+            compute_residual_and_error._spec().input_pin(4), 4, op, -1
+        )
         self._inputs.append(self._field_or_fields_container2)
 
     @property
@@ -326,6 +364,28 @@ def norm_calculation_type(self):
         """
         return self._norm_calculation_type
 
+    @property
+    def field_reference(self):
+        """Allows to connect field_reference input to the operator.
+
+        Field reference for the normalization step,
+        default: 0 for entry 1, 1 for
+        residuals - optional
+
+        Parameters
+        ----------
+        my_field_reference : int
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.math.compute_residual_and_error()
+        >>> op.inputs.field_reference.connect(my_field_reference)
+        >>> # or
+        >>> op.inputs.field_reference(my_field_reference)
+        """
+        return self._field_reference
+
     @property
     def field_or_fields_container2(self):
         """Allows to connect field_or_fields_container2 input to the operator.
@@ -359,6 +419,8 @@ class OutputsComputeResidualAndError(_Outputs):
     >>> # Connect inputs : op.inputs. ...
     >>> result_residuals = op.outputs.residuals()
     >>> result_error = op.outputs.error()
+    >>> result_residuals_normalization_factor = op.outputs.residuals_normalization_factor()
+    >>> result_error_normalization_factor = op.outputs.error_normalization_factor()
     """
 
     def __init__(self, op: Operator):
@@ -395,3 +457,35 @@ def __init__(self, op: Operator):
             op,
         )
         self._outputs.append(self.error_as_fields_container)
+        self.residuals_normalization_factor_as_field = Output(
+            _modify_output_spec_with_one_type(
+                compute_residual_and_error._spec().output_pin(2), "field"
+            ),
+            2,
+            op,
+        )
+        self._outputs.append(self.residuals_normalization_factor_as_field)
+        self.residuals_normalization_factor_as_fields_container = Output(
+            _modify_output_spec_with_one_type(
+                compute_residual_and_error._spec().output_pin(2), "fields_container"
+            ),
+            2,
+            op,
+        )
+        self._outputs.append(self.residuals_normalization_factor_as_fields_container)
+        self.error_normalization_factor_as_field = Output(
+            _modify_output_spec_with_one_type(
+                compute_residual_and_error._spec().output_pin(3), "field"
+            ),
+            3,
+            op,
+        )
+        self._outputs.append(self.error_normalization_factor_as_field)
+        self.error_normalization_factor_as_fields_container = Output(
+            _modify_output_spec_with_one_type(
+                compute_residual_and_error._spec().output_pin(3), "fields_container"
+            ),
+            3,
+            op,
+        )
+        self._outputs.append(self.error_normalization_factor_as_fields_container)

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

@@ -55,6 +55,7 @@
 from .merge_weighted_fields import merge_weighted_fields 
 from .merge_weighted_fields_containers import merge_weighted_fields_containers 
 from .mesh import mesh 
+from .mesh_to_mc import mesh_to_mc 
 from .overlap_fields import overlap_fields 
 from .producer_consumer_for_each import producer_consumer_for_each 
 from .property_field import property_field 

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

@@ -12,7 +12,7 @@
 
 
 class field_to_fc(Operator):
-    """Creates a field container containing the field provided on pin 0.
+    """Creates a fields container containing the field provided on pin 0.
 
     Parameters
     ----------
@@ -59,7 +59,7 @@ def __init__(self, field=None, label=None, config=None, server=None):
     @staticmethod
     def _spec():
         description = (
-            """Creates a field container containing the field provided on pin 0."""
+            """Creates a fields container containing the field provided on pin 0."""
         )
         spec = Specification(
             description=description,