Use gRPC functionality for inline functions (#639)

* fix use gRPC functionality

* refactor component_queries

* Made integer bool and added return type

Not sure why the parameter "integer" was a string in the default but
treated as a bool in the code. So I've made it a bool.

Additionally it didn't make sense for it to have a default value because
there's an equal number of integers versus floats. It would be better to
have to specify which is being requested whenever the method is called.

* simplified param parsing and changed selection status docstring

* altered all component queries to use new changes

* renamed class to reflect new query-running responsibilities

* refactored everything now except for selection queries (inc docstrings

* refactored all remaining selection queries

* add edge case testing

* remove unused import

* cannot use mute on line_geometry fixture

Co-authored-by: jgd10 <[email protected]>

Author: akaszynski

ansys/mapdl/core/inline_functions/component_queries.py

@@ -1,7 +1,7 @@
-from .core import _ParameterParsing
+from .core import _QueryExecution
 
 
-class _ConnectivityQueries(_ParameterParsing):
+class _ConnectivityQueries(_QueryExecution):
     _mapdl = None
 
     def nelem(self, e, npos) -> int:
@@ -40,8 +40,7 @@ def nelem(self, e, npos) -> int:
         >>> positions
         [2, 14, 17, 5, 53, 63, 99, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
         """
-        response = self._mapdl.run(f"_=NELEM({e},{npos})")
-        return self._parse_parameter_integer_response(response)
+        return self._run_query(f'NELEM({e},{npos})', integer=True)
 
     def enextn(self, n, loc) -> int:
         """Returns the ``loc`` element connected to node ``n``.
@@ -80,5 +79,4 @@ def enextn(self, n, loc) -> int:
         >>> elements
         [61, 71]
         """
-        response = self._mapdl.run(f"_=ENEXTN({n},{loc})")
-        return self._parse_parameter_integer_response(response)
+        return self._run_query(f'ENEXTN({n},{loc})', integer=True)

ansys/mapdl/core/inline_functions/connectivity_queries.py

@@ -1,5 +1,8 @@
 import warnings
 from enum import IntEnum
+from typing import Union
+
+QUERY_NAME = "__QUERY_PARM__"
 
 
 class SelectionStatus(IntEnum):
@@ -29,11 +32,12 @@ class SelectionStatus(IntEnum):
     1
 
     We can use ``Query.nsel`` to interrogate the selection status
-    of the node. The response is an ``enum.IntEnum`` object. If
-    you query a node that does not exist, it will return a status
-    ``SelectionStatus.UNDEFINED``.
+    of the node. We can get the ``Query`` object from the
+    ``mapdl.queries`` property. The response is an
+    ``enum.IntEnum`` object. If you query a node that does not
+    exist, it will return a status ``SelectionStatus.UNDEFINED``.
 
-    >>> q = Query(mapdl)
+    >>> q = mapdl.queries
     >>> q.nsel(n1)
     <SelectionStatus.SELECTED: 1>
     >>> mapdl.nsel('NONE')
@@ -48,8 +52,35 @@ class SelectionStatus(IntEnum):
     SELECTED = 1
 
 
-class _ParameterParsing:
+class _QueryExecution:
+
+    def _run_query(self, command: str, integer: bool) -> Union[int, float]:
+        # import here to avoid circular import
+        from ansys.mapdl.core.mapdl_grpc import MapdlGrpc
+
+        # non_interactive mode won't work with these commands
+        if self._mapdl._store_commands:
+            raise RuntimeError(
+                "Inline MAPDL functions are incompatible with the "
+                "non_interactive mode."
+            )
+
+        # use the underlying gRPC method if available to avoid parsing the string
+        resp = self._mapdl._run(f"{QUERY_NAME}={command}")
+        if isinstance(self._mapdl, MapdlGrpc):
+            value = self._mapdl.scalar_param(QUERY_NAME)
+            if value is None:
+                raise RuntimeError(resp)
+            if integer:
+                return int(value)
+            return value
+        else:
+            if integer:
+                return self._parse_parameter_integer_response(resp)
+            return self._parse_parameter_float_response(resp)
+
     def _parse_parameter_integer_response(self, response) -> int:
+        """Parse integer response."""
         return int(self._parse_parameter_float_response(response))
 
     @staticmethod

ansys/mapdl/core/inline_functions/core.py

@@ -1,7 +1,7 @@
-from .core import _ParameterParsing
+from .core import _QueryExecution
 
 
-class _AngleQueries(_ParameterParsing):
+class _AngleQueries(_QueryExecution):
     _mapdl = None
 
     def anglen(self, n1, n2, n3) -> float:
@@ -42,8 +42,7 @@ def anglen(self, n1, n2, n3) -> float:
         >>> angle*180./pi
         90.0
         """
-        response = self._mapdl.run(f"_=ANGLEN({n1},{n2},{n3})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'ANGLEN({n1},{n2},{n3})', integer=False)
 
     def anglek(self, k1, k2, k3) -> float:
         """Return the angle between 3 keypoints where ``k1`` is the vertex.
@@ -84,11 +83,10 @@ def anglek(self, k1, k2, k3) -> float:
         >>> angle*180./pi
         45.0
         """
-        response = self._mapdl.run(f"_=ANGLEK({k1},{k2},{k3})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'ANGLEK({k1},{k2},{k3})', integer=False)
 
 
-class _AreaQueries(_ParameterParsing):
+class _AreaQueries(_QueryExecution):
     _mapdl = None
 
     def areand(self, n1, n2, n3) -> float:
@@ -121,8 +119,7 @@ def areand(self, n1, n2, n3) -> float:
         >>> area = mapdl.queries.areand(n1, n2, n3)
         0.5
         """
-        response = self._mapdl.run(f"_=AREAND({n1},{n2},{n3})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'AREAND({n1},{n2},{n3})', integer=False)
 
     def areakp(self, k1, k2, k3) -> float:
         """Area of the triangle with vertices at keypoints ``k1``, ``k2``, and ``k3``.
@@ -154,11 +151,10 @@ def areakp(self, k1, k2, k3) -> float:
         >>> mapdl.queries.areakp(k1, k2, k3)
         0.2545584412
         """
-        response = self._mapdl.run(f"_=AREAKP({k1},{k2},{k3})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'AREAKP({k1},{k2},{k3})', integer=False)
 
 
-class _DistanceQueries(_ParameterParsing):
+class _DistanceQueries(_QueryExecution):
     _mapdl = None
 
     def distnd(self, n1, n2) -> float:
@@ -188,8 +184,7 @@ def distnd(self, n1, n2) -> float:
         >>> mapdl.queries.distnd(n1, n2)
         1.0
         """
-        response = self._mapdl.run(f"_=DISTND({n1},{n2})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'DISTND({n1},{n2})', integer=False)
 
     def distkp(self, k1, k2) -> float:
         """Compute the distance between keypoints ``k1`` and ``k2``.
@@ -222,5 +217,4 @@ def distkp(self, k1, k2) -> float:
         >>> sqrt(2)
         1.4142135623730951
         """
-        response = self._mapdl.run(f"_=DISTKP({k1},{k2})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'DISTKP({k1},{k2})', integer=False)

ansys/mapdl/core/inline_functions/geometry_queries.py

@@ -77,17 +77,17 @@ class Query(
     --------
     In this example we construct a solid box and mesh it. Then we use
     the ``Query`` methods ``nx``, ``ny``, and ``nz`` to find the
-    cartesian coordinates of the first node.
+    cartesian coordinates of the first node. We can access these
+    through the ``mapdl.queries`` property.
 
     >>> from ansys.mapdl.core import launch_mapdl
-    >>> from ansys.mapdl.core.inline_functions import Query
     >>> mapdl = launch_mapdl()
     >>> mapdl.prep7()
     >>> mapdl.et(1, 'SOLID5')
     >>> mapdl.block(0, 10, 0, 20, 0, 30)
     >>> mapdl.esize(2)
     >>> mapdl.vmesh('ALL')
-    >>> q = Query(mapdl)
+    >>> q = mapdl.queries
     >>> q.nx(1), q.ny(1), q.nz(1)
     0.0 20.0 0.0
     """

ansys/mapdl/core/inline_functions/inline_functions.py

@@ -1,7 +1,7 @@
-from .core import _ParameterParsing
+from .core import _QueryExecution
 
 
-class _LineFractionCoordinateQueries(_ParameterParsing):
+class _LineFractionCoordinateQueries(_QueryExecution):
     _mapdl = None
 
     def lx(self, n: int, lfrac: float) -> float:
@@ -29,19 +29,17 @@ def lx(self, n: int, lfrac: float) -> float:
         Here we construct a line between the coordinates ``(0, 0, 0)``
         and ``(1, 2, 3)`` then find the X-coordinate halfway along the line.
 
-        >>> from ansys.mapdl.core.inline_functions import Query
         >>> from ansys.mapdl.core import launch_mapdl
         >>> mapdl = launch_mapdl()
         >>> mapdl.prep7()
         >>> k0 = mapdl.k(1, 0, 0, 0)
         >>> k1 = mapdl.k(2, 1, 2, 3)
         >>> l0 = mapdl.l(k0, k1)
-        >>> q = Query(mapdl)
+        >>> q = mapdl.queries
         >>> q.lx(l0, 0.5)
         0.5
         """
-        response = self._mapdl.run(f"_=LX({n},{lfrac})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'LX({n}, {lfrac})', integer=False)
 
     def ly(self, n: int, lfrac: float) -> float:
         """Y-coordinate of line ``n`` at length fraction ``lfrac``.
@@ -68,19 +66,17 @@ def ly(self, n: int, lfrac: float) -> float:
         Here we construct a line between the coordinates ``(0, 0, 0)``
         and ``(1, 2, 3)`` then find the Y-coordinate halfway along the line.
 
-        >>> from ansys.mapdl.core.inline_functions import Query
         >>> from ansys.mapdl.core import launch_mapdl
         >>> mapdl = launch_mapdl()
         >>> mapdl.prep7()
         >>> k0 = mapdl.k(1, 0, 0, 0)
         >>> k1 = mapdl.k(2, 1, 2, 3)
         >>> l0 = mapdl.l(k0, k1)
-        >>> q = Query(mapdl)
+        >>> q = mapdl.queries
         >>> q.ly(l0, 0.5)
         1.0
         """
-        response = self._mapdl.run(f"_=LY({n},{lfrac})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'LY({n}, {lfrac})', integer=False)
 
     def lz(self, n: int, lfrac: float) -> float:
         """Z-coordinate of line ``n`` at length fraction ``lfrac``.
@@ -107,22 +103,20 @@ def lz(self, n: int, lfrac: float) -> float:
         Here we construct a line between the coordinates ``(0, 0, 0)``
         and ``(1, 2, 3)`` then find the Z-coordinate halfway along the line.
 
-        >>> from ansys.mapdl.core.inline_functions import Query
         >>> from ansys.mapdl.core import launch_mapdl
         >>> mapdl = launch_mapdl()
         >>> mapdl.prep7()
         >>> k0 = mapdl.k(1, 0, 0, 0)
         >>> k1 = mapdl.k(2, 1, 2, 3)
         >>> l0 = mapdl.l(k0, k1)
-        >>> q = Query(mapdl)
+        >>> q = mapdl.queries
         >>> q.lz(l0, 0.5)
         1.5
         """
-        response = self._mapdl.run(f"_=LZ({n},{lfrac})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'LZ({n}, {lfrac})', integer=False)
 
 
-class _LineFractionSlopeQueries(_ParameterParsing):
+class _LineFractionSlopeQueries(_QueryExecution):
     _mapdl = None
 
     def lsx(self, n: int, lfrac: float) -> float:
@@ -151,19 +145,17 @@ def lsx(self, n: int, lfrac: float) -> float:
         Here we construct a line between the coordinates ``(0, 0, 0)``
         and ``(1, 2, 2)`` then find the X-slope halfway along the line.
 
-        >>> from ansys.mapdl.core.inline_functions import Query
         >>> from ansys.mapdl.core import launch_mapdl
         >>> mapdl = launch_mapdl()
         >>> mapdl.prep7()
         >>> k0 = mapdl.k(1, 0, 0, 0)
         >>> k1 = mapdl.k(2, 1, 2, 2)
         >>> l0 = mapdl.l(k0, k1)
-        >>> q = Query(mapdl)
+        >>> q = mapdl.queries
         >>> q.lsx(l0, 0.5)
         0.3333333333
         """
-        response = self._mapdl.run(f"_=LSX({n},{lfrac})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'LSX({n}, {lfrac})', integer=False)
 
     def lsy(self, n: int, lfrac: float) -> float:
         """Y-slope of line ``n`` at length fraction ``lfrac``.
@@ -191,19 +183,17 @@ def lsy(self, n: int, lfrac: float) -> float:
         Here we construct a line between the coordinates ``(0, 0, 0)``
         and ``(1, 2, 2)`` then find the Y-slope halfway along the line.
 
-        >>> from ansys.mapdl.core.inline_functions import Query
         >>> from ansys.mapdl.core import launch_mapdl
         >>> mapdl = launch_mapdl()
         >>> mapdl.prep7()
         >>> k0 = mapdl.k(1, 0, 0, 0)
         >>> k1 = mapdl.k(2, 1, 2, 2)
         >>> l0 = mapdl.l(k0, k1)
-        >>> q = Query(mapdl)
+        >>> q = mapdl.queries
         >>> q.lsy(l0, 0.5)
         0.6666666667
         """
-        response = self._mapdl.run(f"_=LSY({n},{lfrac})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'LSY({n}, {lfrac})', integer=False)
 
     def lsz(self, n: int, lfrac: float) -> float:
         """Z-slope of line ``n`` at length fraction ``lfrac``.
@@ -231,16 +221,14 @@ def lsz(self, n: int, lfrac: float) -> float:
         Here we construct a line between the coordinates ``(0, 0, 0)``
         and ``(1, 2, 2)`` then find the Z-slope halfway along the line.
 
-        >>> from ansys.mapdl.core.inline_functions import Query
         >>> from ansys.mapdl.core import launch_mapdl
         >>> mapdl = launch_mapdl()
         >>> mapdl.prep7()
         >>> k0 = mapdl.k(1, 0, 0, 0)
         >>> k1 = mapdl.k(2, 1, 2, 2)
         >>> l0 = mapdl.l(k0, k1)
-        >>> q = Query(mapdl)
+        >>> q = mapdl.queries
         >>> q.lsz(l0, 0.5)
         0.6666666667
         """
-        response = self._mapdl.run(f"_=LSZ({n},{lfrac})")
-        return self._parse_parameter_float_response(response)
+        return self._run_query(f'LSZ({n}, {lfrac})', integer=False)

ansys/mapdl/core/inline_functions/line_queries.py

@@ -1,7 +1,7 @@
-from .core import _ParameterParsing
+from .core import _QueryExecution
 
 
-class _EntityNearestEntityQueries(_ParameterParsing):
+class _EntityNearestEntityQueries(_QueryExecution):
     _mapdl = None
 
     def nnear(self, n: int) -> int:
@@ -37,9 +37,7 @@ def nnear(self, n: int) -> int:
         >>> node_number, nearest_node
         (112, 103)
         """
-        response = self._mapdl.run(f"_=NNEAR({n})")
-        integer = self._parse_parameter_integer_response(response)
-        return integer
+        return self._run_query(f'NNEAR({n})', integer=True)
 
     def knear(self, k: int) -> int:
         """Returns the selected keypoint nearest keypoint `k`.
@@ -71,9 +69,7 @@ def knear(self, k: int) -> int:
         >>> q.knear(k1) == k2
         True
         """
-        response = self._mapdl.run(f"_=KNEAR({k})")
-        integer = self._parse_parameter_integer_response(response)
-        return integer
+        return self._run_query(f'KNEAR({k})', integer=True)
 
     def enearn(self, n: int) -> int:
         """Returns the selected element nearest node `n`.
@@ -110,6 +106,4 @@ def enearn(self, n: int) -> int:
         >>> node_number, nearest_element
         (112, 22)
         """
-        response = self._mapdl.run(f"_=ENEARN({n})")
-        integer = self._parse_parameter_integer_response(response)
-        return integer
+        return self._run_query(f'ENEARN({n})', integer=True)