Merge branch 'develop' into release-0.6.0

Author: PProfizi

ansys/dpf/core/__init__.py

@@ -20,6 +20,7 @@
 from ansys.dpf.core.field import Field, FieldDefinition
 from ansys.dpf.core.dimensionality import Dimensionality
 from ansys.dpf.core.property_field import PropertyField
+from ansys.dpf.core.string_field import StringField
 from ansys.dpf.core.fields_container import FieldsContainer
 from ansys.dpf.core.meshes_container import MeshesContainer
 from ansys.dpf.core.scopings_container import ScopingsContainer
@@ -50,6 +51,7 @@
     make_tmp_dir_server,
 )
 from ansys.dpf.core.time_freq_support import TimeFreqSupport
+from ansys.dpf.core.generic_support import GenericSupport
 from ansys.dpf.core.meshed_region import MeshedRegion
 from ansys.dpf.core.elements import element_types
 from ansys.dpf.core.result_info import ResultInfo

ansys/dpf/core/_custom_operators_helpers.py

@@ -1,9 +1,10 @@
 from ansys.dpf.gate import capi, external_operator_capi
 from enum import Enum
+
 from ansys.dpf.core import (
     field, property_field, scoping, collection, data_sources, meshed_region, time_freq_support, \
     workflow, data_tree, dpf_operator, fields_container, scopings_container, \
-    meshes_container, result_info
+    meshes_container, result_info, string_field
 )
 
 external_operator_api = external_operator_capi.ExternalOperatorCAPI
@@ -21,6 +22,7 @@ def __operator_main__(operator_functor, data):
     (float, external_operator_api.external_operator_put_out_double),
     (field.Field, external_operator_api.external_operator_put_out_field),
     (property_field.PropertyField, external_operator_api.external_operator_put_out_property_field),
+    (string_field.StringField, external_operator_api.external_operator_put_out_string_field),
     (scoping.Scoping, external_operator_api.external_operator_put_out_scoping),
     (collection.Collection, external_operator_api.external_operator_put_out_collection),
     (data_sources.DataSources, external_operator_api.external_operator_put_out_data_sources),
@@ -41,6 +43,8 @@ def __operator_main__(operator_functor, data):
     (field.Field, external_operator_api.external_operator_get_in_field, "field"),
     (property_field.PropertyField, external_operator_api.external_operator_get_in_property_field,
      "property_field"),
+    (string_field.StringField, external_operator_api.external_operator_get_in_string_field,
+     "string_field"),
     (scoping.Scoping, external_operator_api.external_operator_get_in_scoping,
      "scoping"),
     (fields_container.FieldsContainer,

ansys/dpf/core/available_result.py

@@ -112,6 +112,7 @@ def __init__(self, availableresult):
         self._properties = {"scripting_name": availableresult.properties["scripting_name"],
                             "location": availableresult.properties["loc_name"]}
         self._sub_res = availableresult.sub_res
+        self._qualifiers = availableresult.qualifiers
 
     def __str__(self):
         txt = (
@@ -214,6 +215,13 @@ def physical_name(self) -> str:
         """Name of the result with spaces"""
         return self._physics_name
 
+    @property
+    def qualifiers(self) -> list:
+        """Returns the list of qualifiers (equivalent to label spaces)
+        available for a given Result. These qualifiers can then be used to request the result
+        on specified locations/properties.
+        """
+        return self._qualifiers
 
 _result_properties = {
     "S": {"location": "ElementalNodal", "scripting_name": "stress"},
@@ -253,10 +261,13 @@ def available_result_from_name(name) -> AvailableResult:
     for key, item in _result_properties.items():
         if item["scripting_name"] == name:
             from types import SimpleNamespace
-            availableresult = SimpleNamespace(name=key, physicsname=name, ncomp=None,
-                                               dimensionality=None,
-                                               homogeneity=None,
-                                               unit=None, sub_res={},
-                                               properties={"loc_name": item["location"],
-                                                           "scripting_name": name})
+            availableresult = SimpleNamespace(
+                name=key, physicsname=name, ncomp=None,
+                dimensionality=None,
+                homogeneity=None,
+                unit=None, sub_res={},
+                properties={"loc_name": item["location"],
+                            "scripting_name": name},
+                qualifiers=[])
+
             return AvailableResult(availableresult)

ansys/dpf/core/collection.py

@@ -12,16 +12,13 @@
 
 from ansys.dpf.core.server_types import BaseServer
 from ansys.dpf.core.scoping import Scoping
-from ansys.dpf.core.time_freq_support import TimeFreqSupport
+from ansys.dpf.core.label_space import LabelSpace
 from ansys.dpf.core import server as server_module
 from ansys.dpf.gate import (
     collection_capi,
     collection_grpcapi,
-    label_space_capi,
-    label_space_grpcapi,
     data_processing_capi,
     data_processing_grpcapi,
-    object_handler,
     dpf_vector,
     dpf_array
 )
@@ -216,7 +213,9 @@ def _get_entries(self, label_space_or_index):
             Entries corresponding to the request.
         """
         if isinstance(label_space_or_index, dict):
-            client_label_space = self._create_client_label_space(label_space_or_index)
+            client_label_space = LabelSpace(
+                label_space=label_space_or_index, obj=self, server=self._server
+            )
             num = self._api.collection_get_num_obj_for_label_space(self, client_label_space)
             out = []
             for i in range(0, num):
@@ -268,9 +267,10 @@ def get_label_space(self, index):
             Scoping of the requested entry. For example,
             ``{"time": 1, "complex": 0}``.
         """
-        return self._create_dict_from_client_label_space(
-            self._api.collection_get_obj_label_space_by_index(self, index)
-        )
+        return LabelSpace(
+                label_space=self._api.collection_get_obj_label_space_by_index(self, index),
+                server=self._server
+            ).__dict__()
 
     def get_available_ids_for_label(self, label="time"):
         """Retrieve the IDs assigned to an input label.
@@ -333,11 +333,6 @@ def __getitem__(self, index):
 
         return self._get_entries(index)
 
-    @property
-    def _label_space_api(self):
-        return self._server.get_api_for_type(capi=label_space_capi.LabelSpaceCAPI,
-                                             grpcapi=label_space_grpcapi.LabelSpaceGRPCAPI)
-
     @property
     def _data_processing_core_api(self):
         core_api = self._server.get_api_for_type(
@@ -346,27 +341,6 @@ def _data_processing_core_api(self):
         core_api.init_data_processing_environment(self)
         return core_api
 
-    def _create_client_label_space(self, label_space):
-        client_label_space = object_handler.ObjHandler(
-            self._data_processing_core_api,
-            self._label_space_api.label_space_new_for_object(self)
-        )
-        for key, id in label_space.items():
-            self._label_space_api.label_space_add_data(client_label_space, key, id)
-        return client_label_space
-
-    def _create_dict_from_client_label_space(self, client_label_space):
-        if isinstance(client_label_space, dict):
-            return client_label_space
-        out = {}
-        client_label_space = object_handler.ObjHandler(
-            self._data_processing_core_api, client_label_space
-        )
-        for i in range(0, self._label_space_api.label_space_get_size(client_label_space)):
-            out[self._label_space_api.label_space_get_labels_name(client_label_space, i)] = \
-                self._label_space_api.label_space_get_labels_value(client_label_space, i)
-        return out
-
     def _add_entry(self, label_space, entry):
         """Update or add an entry at a requested label space.
 
@@ -377,7 +351,7 @@ def _add_entry(self, label_space, entry):
         entry : Field or Scoping
             DPF entry to add.
         """
-        client_label_space = self._create_client_label_space(label_space)
+        client_label_space = LabelSpace(label_space=label_space, obj=self, server=self._server)
         self._api.collection_add_entry(self, client_label_space, entry)
 
     def _get_time_freq_support(self):
@@ -387,6 +361,7 @@ def _get_time_freq_support(self):
         -------
         time_freq_support : TimeFreqSupport
         """
+        from ansys.dpf.core.time_freq_support import TimeFreqSupport
         from ansys.dpf.gate import support_capi, support_grpcapi, object_handler, \
             data_processing_capi, data_processing_grpcapi
         data_api = self._server.get_api_for_type(
@@ -581,3 +556,54 @@ def get_integral_entries(self):
             return dpf_array.DPFArray(vec)
         except NotImplementedError:
             return self._api.collection_get_data_as_double(self, 0)
+
+
+class StringCollection(Collection):
+    """Creates a collection of strings with a list.
+
+    The collection of integral is the equivalent of an array of
+    data sent server side. It can be used to efficiently stream
+    large data to the server.
+
+    Parameters
+    ----------
+    list : list[float], numpy.array
+        list to transfer server side
+
+    Notes
+    -----
+    Used by default by the ``'Operator'`` and the``'Workflow'`` when a
+    list is connected or returned.
+    """
+
+    def __init__(self, list=None, server=None, collection=None, local: bool = False):
+        super().__init__(server=server, collection=collection)
+        self._sub_type = str
+        if self._internal_obj is None:
+            if self._server.has_client():
+                if local:
+                    self._internal_obj = self._api.collection_of_string_new_local(
+                        self._server.client
+                    )
+                else:
+                    self._internal_obj = self._api.collection_of_string_new_on_client(
+                        self._server.client
+                    )
+            else:
+                self._internal_obj = self._api.collection_of_string_new()
+        if list is not None:
+            self._set_integral_entries(list)
+
+    def create_subtype(self, obj_by_copy):
+        return str(obj_by_copy)
+
+    def _set_integral_entries(self, input):
+        for s in input:
+            self._api.collection_add_string_entry(self, s)
+
+    def get_integral_entries(self):
+        num = self._api.collection_get_size(self)
+        out = []
+        for i in range(num):
+            out.append(self._api.collection_get_string_entry(self, i))
+        return out

ansys/dpf/core/common.py

@@ -9,9 +9,10 @@
 import re
 import sys
 from enum import Enum
-import numpy as np
+
 from ansys.dpf.core.misc import module_exists
 from ansys.dpf.gate.common import locations, ProgressBarBase  # noqa: F401
+from ansys.dpf.gate.dpf_vector import get_size_of_list as _get_size_of_list  # noqa: F401
 
 def _camel_to_snake_case(name):
     return re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()
@@ -82,9 +83,10 @@ class types(Enum):
     operator = 19
     data_tree = 20
     vec_string = 21
-    fields_container = 22
-    scopings_container = 23
-    meshes_container = 24
+    string_field = 22
+    fields_container = 23
+    scopings_container = 24
+    meshes_container = 25
 
 
 def types_enum_to_types():
@@ -97,6 +99,7 @@ def types_enum_to_types():
         meshed_region,
         meshes_container,
         property_field,
+        string_field,
         result_info,
         scoping,
         scopings_container,
@@ -128,6 +131,7 @@ def types_enum_to_types():
         types.scoping: scoping.Scoping,
         types.vec_int: dpf_vector.DPFVectorInt,
         types.vec_double: dpf_vector.DPFVectorDouble,
+        types.string_field: string_field.StringField,
     }
 
 
@@ -255,11 +259,3 @@ def _common_progress_bar(text, unit, tot_size=None):
 
 def _common_percentage_progress_bar(text):
     return TqdmProgressBar(text, "%", 100)
-
-
-def _get_size_of_list(list):
-    if isinstance(list, (np.generic, np.ndarray)):
-        return list.size
-    elif not hasattr(list, '__iter__'):
-        return 1
-    return len(list)

ansys/dpf/core/data_tree.py

@@ -10,16 +10,14 @@
 
 from ansys.dpf.core.mapping_types import types
 from ansys.dpf.core import server as server_module
+from ansys.dpf.core import collection
 from ansys.dpf.core import errors
 from ansys.dpf.gate import (
     dpf_data_tree_abstract_api,
     dpf_data_tree_capi,
     dpf_data_tree_grpcapi,
     data_processing_capi,
     data_processing_grpcapi,
-    collection_capi,
-    collection_grpcapi,
-    object_handler,
     integral_types,
 )
 
@@ -139,19 +137,11 @@ def add_data(self, key, value):
                         self, key, value, len(value)
                     )
                 elif len(value) > 0 and isinstance(value[0], str):
-                    if self._server.has_client():
-                        coll_obj = object_handler.ObjHandler(
-                            data_processing_api=self._core_api,
-                            internal_obj=self._coll_api.collection_of_string_new_local(
-                                self._server.client
-                            )
-                        )
-                    else:
-                        coll_obj = object_handler.ObjHandler(
-                            data_processing_api=self._core_api,
-                            internal_obj=self._coll_api.collection_of_string_new())
-                    for s in value:
-                        self._coll_api.collection_add_string_entry(coll_obj, s)
+                    coll_obj = collection.StringCollection(
+                        list=value,
+                        local=True,
+                        server=self._server
+                    )
                     self._api.dpf_data_tree_set_string_collection_attribute(
                         self, key, coll_obj
                     )
@@ -184,14 +174,6 @@ def _core_api(self):
         core_api.init_data_processing_environment(self)
         return core_api
 
-    @property
-    def _coll_api(self):
-        coll_api = self._server.get_api_for_type(
-            capi=collection_capi.CollectionCAPI,
-            grpcapi=collection_grpcapi.CollectionGRPCAPI)
-        coll_api.init_collection_environment(self)
-        return coll_api
-
     def to_fill(self):
         """
         This method allows to access and modify the local copy of the data_tree
@@ -458,14 +440,11 @@ def get_as(self, name, type_to_return=types.string):
             self._api.dpf_data_tree_get_vec_int_attribute(self, name, out, out.internal_size)
             out = out.tolist()
         elif type_to_return == types.vec_string:
-            coll_obj = object_handler.ObjHandler(
-                data_processing_api=self._core_api,
-                internal_obj=self._api.dpf_data_tree_get_string_collection_attribute(self, name)
+            coll_obj = collection.StringCollection(
+                collection=self._api.dpf_data_tree_get_string_collection_attribute(self, name),
+                server=self._server
             )
-            num = self._coll_api.collection_get_size(coll_obj)
-            out = []
-            for i in range(num):
-                out.append(self._coll_api.collection_get_string_entry(coll_obj, i))
+            out = coll_obj.get_integral_entries()
         elif type_to_return == types.data_tree:
             obj = self._api.dpf_data_tree_get_sub_tree(self, name)
             out = DataTree(data_tree=obj, server=self._server)