add capability to disable dynamic result property creation (#115)

Author: cbellot000

ansys/dpf/core/available_result.py

@@ -44,12 +44,12 @@ def __init__(self, availableresult):
 
     def __str__(self):
         txt = (
-            self.name
-            + "\n"
-            + 'Operator name: "%s"\n' % self.operator_name
-            + "Number of components: %d\n" % self.n_components
-            + "Dimensionality: %s\n" % self.dimensionality
-            + "Homogeneity: %s\n" % self.homogeneity
+                self.name
+                + "\n"
+                + 'Operator name: "%s"\n' % self.operator_name
+                + "Number of components: %d\n" % self.n_components
+                + "Dimensionality: %s\n" % self.dimensionality
+                + "Homogeneity: %s\n" % self.homogeneity
         )
         if self.unit:
             txt += "Units: %s\n" % self.unit
@@ -167,3 +167,12 @@ def native_scoping_location(self):
     "UTOT": {"location": "Nodal", "scripting_name": "raw_displacement"},
     "RFTOT": {"location": "Nodal", "scripting_name": "raw_reaction_force"},
 }
+
+
+def available_result_from_name(name) -> AvailableResult:
+    message = available_result_pb2.AvailableResultResponse()
+    message.physicsname = name
+    for key, item in _result_properties.items():
+        if item["scripting_name"] == name:
+            message.name = key
+    return AvailableResult(message)

ansys/dpf/core/misc.py

@@ -6,6 +6,7 @@
 
 
 DEFAULT_FILE_CHUNK_SIZE = 524288
+DYNAMIC_RESULTS = True
 
 # ANSYS CPython Workbench environment may not have scooby installed.
 try:

ansys/dpf/core/model.py

@@ -13,6 +13,8 @@
 from ansys.dpf.core.common import types
 from ansys.dpf.core.data_sources import DataSources
 from ansys.dpf.core.results import Results, CommonResults
+from ansys.dpf.core.server import LOG
+from ansys.dpf.core import misc
 from grpc._channel import _InactiveRpcError
 
 
@@ -46,11 +48,14 @@ def __init__(self, data_sources=None, server=None):
 
         self._server = server
         self._metadata = Metadata(data_sources, self._server)
-        try:
-            self._results = Results(self)
-        except Exception as e:
-            self._results = None
-            print(e)
+        if misc.DYNAMIC_RESULTS:
+            try:
+                self._results = Results(self)
+            except Exception as e:
+                self._results = CommonResults(self)
+                LOG.debug(str(e))
+        else:
+            self._results = CommonResults(self)
 
     @property
     def metadata(self):
@@ -234,15 +239,15 @@ def __init__(self, data_sources, server):
         self._server = server
         self._set_data_sources(data_sources)
         self._meshed_region = None
-        self.result_info = None
+        self._result_info = None
         self._stream_provider = None
         self._time_freq_support = None
         self._cache_streams_provider()
-        self._cache_result_info()
 
     def _cache_result_info(self):
         """Store result information."""
-        self.result_info = self._load_result_info()
+        if not self._result_info:
+            self._result_info = self._load_result_info()
 
     def _cache_streams_provider(self):
         """Create a stream provider and cache it."""
@@ -416,6 +421,18 @@ def mesh_provider(self):
         mesh_provider.inputs.connect(self._stream_provider.outputs)
         return mesh_provider
 
+    @property
+    def result_info(self):
+        """Result Info instance.
+
+        Returns
+        -------
+        result_info : :class:`ansys.dpf.core.ResultInfo`
+        """
+        self._cache_result_info()
+
+        return self._result_info
+
     @property
     def available_named_selections(self):
         """List of available named selections.

ansys/dpf/core/result_info.py

@@ -283,7 +283,10 @@ def _get_result(self, numres):
         return available_result.AvailableResult(res)
 
     def __len__(self):
-        return self._get_list().nresult
+        try:
+            return self._get_list().nresult
+        except:
+            return 0
 
     def __iter__(self):
         for i in range(len(self)):

ansys/dpf/core/results.py

@@ -194,7 +194,11 @@ def __init__(self, model, result_info):
         self._time_scoping = None
         self._mesh_scoping = None
         self._location = None
-        self._result_info = result_info
+        if isinstance(result_info, str):
+            from ansys.dpf.core.available_result import available_result_from_name
+            self._result_info = available_result_from_name(result_info)
+        else:
+            self._result_info = result_info
         self._specific_fc_type = None
         from ansys.dpf.core import operators
 
@@ -562,6 +566,15 @@ class CommonResults(Results):
     Used to allow type hints and auto completion for the method:'results'
     of the class:'Results'.
     """
+    def __init__(self, model):
+        self._model = model
+        self._op_map_rev = dict(displacement="displacement",
+                                stress="stress",
+                                elastic_strain="elastic_strain",
+                                structural_temperature="structural_temperature",
+                                temperature="temperature",
+                                electric_potential="electric_potential")
+        self._result_info = model.metadata.result_info
 
     @property
     def displacement(self):

ansys/dpf/core/settings.py

@@ -33,3 +33,22 @@ def disable_interpreter_properties_evaluation() -> bool:
 
 def set_upload_chunk_size(num_bytes = misc.DEFAULT_FILE_CHUNK_SIZE) -> None:
     misc.DEFAULT_FILE_CHUNK_SIZE = num_bytes
+
+def set_dynamic_available_results_capability(value) -> None:
+    """Disables the evaluation of the available results and
+    the dynamic creation of the results properties when a ''Model'' is created.
+
+    Parameters
+    ----------
+    value :  bool
+        With ''True'', models will dynamically generate results properties
+
+    Examples
+    --------
+
+    >>> from ansys.dpf import core as dpf
+    >>> dpf.settings.set_dynamic_available_results_capability(False)
+    >>> dpf.settings.set_dynamic_available_results_capability(True)
+
+    """
+    misc.DYNAMIC_RESULTS = value

tests/test_model.py

@@ -194,6 +194,21 @@ def test_result_splitted_subset(allkindofcomplexity):
     assert len(vol.eval()[1].scoping) == 1
 
 
+def test_result_not_dynamic(plate_msup):
+    dpf.core.settings.set_dynamic_available_results_capability(False)
+    model = dpf.core.Model(plate_msup)
+    assert isinstance(model.results, dpf.core.results.CommonResults)
+    stress = model.results.stress
+    fc = stress.on_time_scoping([1, 2, 3, 19]).eval()
+    assert len(fc) == 4
+    fc = stress.on_time_scoping([0.115, 0.125]).eval()
+    assert len(fc) == 2
+    assert np.allclose(
+        fc.time_freq_support.time_frequencies.data, np.array([0.115, 0.125])
+    )
+    dis = model.results.displacement().eval()
+    dpf.core.settings.set_dynamic_available_results_capability(True)
+
 # @pytest.mark.skipif(NO_PLOTTING, reason="Requires system to support plotting")
 # def test_displacements_plot(static_model):
 #     from pyvista import CameraPosition