update generated code

Author: PProfizi

doc/source/_static/dpf_operators.html

@@ -268,6 +268,7 @@
 from .smisc import smisc
 from .specific_heat import specific_heat
 from .spectrum_data import spectrum_data
+from .state_variable import state_variable
 from .static_pressure import static_pressure
 from .stiffness_matrix_energy import stiffness_matrix_energy
 from .strain_eqv_as_mechanical import strain_eqv_as_mechanical

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

@@ -58,14 +58,25 @@ class acceleration(Operator):
         If true the field is rotated to global
         coordinate system (default true)
     mesh : MeshedRegion or MeshesContainer, optional
-        Prevents from reading the mesh in the result
-        files
+        Mesh. if cylic expansion is to be done, mesh
+        of the base sector
     read_cyclic : int, optional
         If 0 cyclic symmetry is ignored, if 1 cyclic
         sector is read, if 2 cyclic expansion
         is done, if 3 cyclic expansion is
         done and stages are merged (default
         is 1)
+    expanded_meshed_region : MeshedRegion or MeshesContainer, optional
+        Mesh expanded, use if cyclic expansion is to
+        be done.
+    sectors_to_expand : Scoping or ScopingsContainer, optional
+        Sectors to expand (start at 0), for
+        multistage: use scopings container
+        with 'stage' label, use if cyclic
+        expansion is to be done.
+    phi : float, optional
+        Angle phi in degrees (default value 0.0), use
+        if cyclic expansion is to be done.
 
     Returns
     -------
@@ -95,6 +106,12 @@ class acceleration(Operator):
     >>> op.inputs.mesh.connect(my_mesh)
     >>> my_read_cyclic = int()
     >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+    >>> my_expanded_meshed_region = dpf.MeshedRegion()
+    >>> op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
+    >>> my_sectors_to_expand = dpf.Scoping()
+    >>> op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
+    >>> my_phi = float()
+    >>> op.inputs.phi.connect(my_phi)
 
     >>> # Instantiate operator and connect inputs in one line
     >>> op = dpf.operators.result.acceleration(
@@ -106,6 +123,9 @@ class acceleration(Operator):
     ...     bool_rotate_to_global=my_bool_rotate_to_global,
     ...     mesh=my_mesh,
     ...     read_cyclic=my_read_cyclic,
+    ...     expanded_meshed_region=my_expanded_meshed_region,
+    ...     sectors_to_expand=my_sectors_to_expand,
+    ...     phi=my_phi,
     ... )
 
     >>> # Get output data
@@ -122,6 +142,9 @@ def __init__(
         bool_rotate_to_global=None,
         mesh=None,
         read_cyclic=None,
+        expanded_meshed_region=None,
+        sectors_to_expand=None,
+        phi=None,
         config=None,
         server=None,
     ):
@@ -144,6 +167,12 @@ def __init__(
             self.inputs.mesh.connect(mesh)
         if read_cyclic is not None:
             self.inputs.read_cyclic.connect(read_cyclic)
+        if expanded_meshed_region is not None:
+            self.inputs.expanded_meshed_region.connect(expanded_meshed_region)
+        if sectors_to_expand is not None:
+            self.inputs.sectors_to_expand.connect(sectors_to_expand)
+        if phi is not None:
+            self.inputs.phi.connect(phi)
 
     @staticmethod
     def _spec():
@@ -227,8 +256,8 @@ def _spec():
                     name="mesh",
                     type_names=["abstract_meshed_region", "meshes_container"],
                     optional=True,
-                    document="""Prevents from reading the mesh in the result
-        files""",
+                    document="""Mesh. if cylic expansion is to be done, mesh
+        of the base sector""",
                 ),
                 14: PinSpecification(
                     name="read_cyclic",
@@ -240,6 +269,29 @@ def _spec():
         done and stages are merged (default
         is 1)""",
                 ),
+                15: PinSpecification(
+                    name="expanded_meshed_region",
+                    type_names=["abstract_meshed_region", "meshes_container"],
+                    optional=True,
+                    document="""Mesh expanded, use if cyclic expansion is to
+        be done.""",
+                ),
+                18: PinSpecification(
+                    name="sectors_to_expand",
+                    type_names=["vector<int32>", "scoping", "scopings_container"],
+                    optional=True,
+                    document="""Sectors to expand (start at 0), for
+        multistage: use scopings container
+        with 'stage' label, use if cyclic
+        expansion is to be done.""",
+                ),
+                19: PinSpecification(
+                    name="phi",
+                    type_names=["double"],
+                    optional=True,
+                    document="""Angle phi in degrees (default value 0.0), use
+        if cyclic expansion is to be done.""",
+                ),
             },
             map_output_pin_spec={
                 0: PinSpecification(
@@ -313,6 +365,12 @@ class InputsAcceleration(_Inputs):
     >>> op.inputs.mesh.connect(my_mesh)
     >>> my_read_cyclic = int()
     >>> op.inputs.read_cyclic.connect(my_read_cyclic)
+    >>> my_expanded_meshed_region = dpf.MeshedRegion()
+    >>> op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
+    >>> my_sectors_to_expand = dpf.Scoping()
+    >>> op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
+    >>> my_phi = float()
+    >>> op.inputs.phi.connect(my_phi)
     """
 
     def __init__(self, op: Operator):
@@ -335,6 +393,14 @@ def __init__(self, op: Operator):
         self._inputs.append(self._mesh)
         self._read_cyclic = Input(acceleration._spec().input_pin(14), 14, op, -1)
         self._inputs.append(self._read_cyclic)
+        self._expanded_meshed_region = Input(
+            acceleration._spec().input_pin(15), 15, op, -1
+        )
+        self._inputs.append(self._expanded_meshed_region)
+        self._sectors_to_expand = Input(acceleration._spec().input_pin(18), 18, op, -1)
+        self._inputs.append(self._sectors_to_expand)
+        self._phi = Input(acceleration._spec().input_pin(19), 19, op, -1)
+        self._inputs.append(self._phi)
 
     @property
     def time_scoping(self):
@@ -488,8 +554,8 @@ def bool_rotate_to_global(self):
     def mesh(self):
         """Allows to connect mesh input to the operator.
 
-        Prevents from reading the mesh in the result
-        files
+        Mesh. if cylic expansion is to be done, mesh
+        of the base sector
 
         Parameters
         ----------
@@ -529,6 +595,71 @@ def read_cyclic(self):
         """
         return self._read_cyclic
 
+    @property
+    def expanded_meshed_region(self):
+        """Allows to connect expanded_meshed_region input to the operator.
+
+        Mesh expanded, use if cyclic expansion is to
+        be done.
+
+        Parameters
+        ----------
+        my_expanded_meshed_region : MeshedRegion or MeshesContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.result.acceleration()
+        >>> op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
+        >>> # or
+        >>> op.inputs.expanded_meshed_region(my_expanded_meshed_region)
+        """
+        return self._expanded_meshed_region
+
+    @property
+    def sectors_to_expand(self):
+        """Allows to connect sectors_to_expand input to the operator.
+
+        Sectors to expand (start at 0), for
+        multistage: use scopings container
+        with 'stage' label, use if cyclic
+        expansion is to be done.
+
+        Parameters
+        ----------
+        my_sectors_to_expand : Scoping or ScopingsContainer
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.result.acceleration()
+        >>> op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
+        >>> # or
+        >>> op.inputs.sectors_to_expand(my_sectors_to_expand)
+        """
+        return self._sectors_to_expand
+
+    @property
+    def phi(self):
+        """Allows to connect phi input to the operator.
+
+        Angle phi in degrees (default value 0.0), use
+        if cyclic expansion is to be done.
+
+        Parameters
+        ----------
+        my_phi : float
+
+        Examples
+        --------
+        >>> from ansys.dpf import core as dpf
+        >>> op = dpf.operators.result.acceleration()
+        >>> op.inputs.phi.connect(my_phi)
+        >>> # or
+        >>> op.inputs.phi(my_phi)
+        """
+        return self._phi
+
 
 class OutputsAcceleration(_Outputs):
     """Intermediate class used to get outputs from

src/ansys/dpf/core/operators/result/acceleration.py

@@ -65,12 +65,6 @@ class accu_eqv_creep_strain(Operator):
     requested_location : str, optional
         Requested location nodal, elemental or
         elementalnodal
-    read_cyclic : int, optional
-        If 0 cyclic symmetry is ignored, if 1 cyclic
-        sector is read, if 2 cyclic expansion
-        is done, if 3 cyclic expansion is
-        done and stages are merged (default
-        is 1)
     read_beams : bool, optional
         Elemental nodal beam results are read if this
         pin is set to true (default is false)
@@ -120,8 +114,6 @@ class accu_eqv_creep_strain(Operator):
     >>> op.inputs.mesh.connect(my_mesh)
     >>> my_requested_location = str()
     >>> op.inputs.requested_location.connect(my_requested_location)
-    >>> my_read_cyclic = int()
-    >>> op.inputs.read_cyclic.connect(my_read_cyclic)
     >>> my_read_beams = bool()
     >>> op.inputs.read_beams.connect(my_read_beams)
     >>> my_split_shells = bool()
@@ -139,7 +131,6 @@ class accu_eqv_creep_strain(Operator):
     ...     bool_rotate_to_global=my_bool_rotate_to_global,
     ...     mesh=my_mesh,
     ...     requested_location=my_requested_location,
-    ...     read_cyclic=my_read_cyclic,
     ...     read_beams=my_read_beams,
     ...     split_shells=my_split_shells,
     ...     shell_layer=my_shell_layer,
@@ -159,7 +150,6 @@ def __init__(
         bool_rotate_to_global=None,
         mesh=None,
         requested_location=None,
-        read_cyclic=None,
         read_beams=None,
         split_shells=None,
         shell_layer=None,
@@ -185,8 +175,6 @@ def __init__(
             self.inputs.mesh.connect(mesh)
         if requested_location is not None:
             self.inputs.requested_location.connect(requested_location)
-        if read_cyclic is not None:
-            self.inputs.read_cyclic.connect(read_cyclic)
         if read_beams is not None:
             self.inputs.read_beams.connect(read_beams)
         if split_shells is not None:
@@ -287,16 +275,6 @@ def _spec():
                     optional=True,
                     document="""Requested location nodal, elemental or
         elementalnodal""",
-                ),
-                14: PinSpecification(
-                    name="read_cyclic",
-                    type_names=["enum dataProcessing::ECyclicReading", "int32"],
-                    optional=True,
-                    document="""If 0 cyclic symmetry is ignored, if 1 cyclic
-        sector is read, if 2 cyclic expansion
-        is done, if 3 cyclic expansion is
-        done and stages are merged (default
-        is 1)""",
                 ),
                 22: PinSpecification(
                     name="read_beams",
@@ -403,8 +381,6 @@ class InputsAccuEqvCreepStrain(_Inputs):
     >>> op.inputs.mesh.connect(my_mesh)
     >>> my_requested_location = str()
     >>> op.inputs.requested_location.connect(my_requested_location)
-    >>> my_read_cyclic = int()
-    >>> op.inputs.read_cyclic.connect(my_read_cyclic)
     >>> my_read_beams = bool()
     >>> op.inputs.read_beams.connect(my_read_beams)
     >>> my_split_shells = bool()
@@ -445,10 +421,6 @@ def __init__(self, op: Operator):
             accu_eqv_creep_strain._spec().input_pin(9), 9, op, -1
         )
         self._inputs.append(self._requested_location)
-        self._read_cyclic = Input(
-            accu_eqv_creep_strain._spec().input_pin(14), 14, op, -1
-        )
-        self._inputs.append(self._read_cyclic)
         self._read_beams = Input(
             accu_eqv_creep_strain._spec().input_pin(22), 22, op, -1
         )
@@ -652,30 +624,6 @@ def requested_location(self):
         """
         return self._requested_location
 
-    @property
-    def read_cyclic(self):
-        """Allows to connect read_cyclic input to the operator.
-
-        If 0 cyclic symmetry is ignored, if 1 cyclic
-        sector is read, if 2 cyclic expansion
-        is done, if 3 cyclic expansion is
-        done and stages are merged (default
-        is 1)
-
-        Parameters
-        ----------
-        my_read_cyclic : int
-
-        Examples
-        --------
-        >>> from ansys.dpf import core as dpf
-        >>> op = dpf.operators.result.accu_eqv_creep_strain()
-        >>> op.inputs.read_cyclic.connect(my_read_cyclic)
-        >>> # or
-        >>> op.inputs.read_cyclic(my_read_cyclic)
-        """
-        return self._read_cyclic
-
     @property
     def read_beams(self):
         """Allows to connect read_beams input to the operator.