def _get_ids(self, np_array=False):
"""
Returns
-------
ids : list[int], numpy.array (if np_array==True)
List of IDs.
Notes
-----
Print a progress bar.
"""
if server_meet_version("2.1", self._server):
service = self._stub.List(self._message)
dtype = np.int32
return _data_get_chunk_(dtype, service, np_array)
else:
out = []
service = self._stub.List(self._message)
for chunk in service:
out.extend(chunk.ids.rep_int)
if np_array:
return np.array(out, dtype=np.int32)
else:
return out
def get_output(self, pin_name, output_type):
"""Retrieve the output of the operator on the pin number.
A progress bar following the workflow state is printed.
Parameters
----------
pin_name : str
Name of the pin to retrieve. This name should be
exposed before with wf.set_output_name
output_type : core.type enum
Type of the requested output.
"""
request = workflow_pb2.WorkflowEvaluationRequest()
request.wf.CopyFrom(self._message)
request.pin_name = pin_name
if output_type is not None:
dpf_operator._write_output_type_to_proto_style(
output_type, request)
if server_meet_version("3.0", self._server):
# handle progress bar
self._server._session.add_workflow(self, "workflow")
out_future = self._stub.Get.future(request)
while out_future.is_active():
self._server._session.listen_to_progress()
out = out_future.result()
else:
out = self._stub.Get(request)
return dpf_operator._convertOutputMessageToPythonInstance(
out, output_type, self._server)
else:
raise ValueError(
"please specify an output type to get the workflow's output")
def named_selection(self, named_selection):
"""Scoping containing the list of nodes or elements in the named selection.
Parameters
----------
named_selection : str
Name of the named selection.
Returns
-------
named_selection : Scoping
"""
if server_meet_version("2.1", self._server):
request = meshed_region_pb2.GetScopingRequest(mesh=self._message)
request.named_selection = named_selection
out = self._stub.GetScoping(request)
return scoping.Scoping(scoping=out, server=self._server)
else:
if hasattr(self, "_stream_provider"):
from ansys.dpf.core.dpf_operator import Operator
op = Operator("scoping_provider_by_ns", server=self._server)
op.connect(1, named_selection)
op.connect(3, self._stream_provider, 0)
return op.get_output(0, types.scoping)
else:
raise Exception(
"Getting a named selection from a meshed region is "
"only implemented for meshed region created from a "
"model for server version 2.0. Please update your server."
)
def _set_ids(self, ids):
"""
Parameters
----------
ids : list of int
IDs to set.
Notes
-----
Print a progress bar.
"""
# must convert to a list for gRPC
if isinstance(ids, range):
ids = np.array(list(ids), dtype=np.int32)
elif not isinstance(ids, (np.ndarray, np.generic)):
ids = np.array(ids, dtype=np.int32)
else:
ids = np.array(list(ids), dtype=np.int32)
metadata = [("size_int", f"{len(ids)}")]
request = scoping_pb2.UpdateIdsRequest()
request.scoping.CopyFrom(self._message)
if server_meet_version("2.1", self._server):
self._stub.UpdateIds(_data_chunk_yielder(request, ids),
metadata=metadata)
else:
self._stub.UpdateIds(_data_chunk_yielder(request, ids, 8.0e6),
metadata=metadata)
def __init__(self, server=None):
if server is None:
server = dpf.core._global_server()
self._server_weak_ref = weakref.ref(server)
if server_meet_version("3.0", self._server):
self._stub = self._connect()
self.__send_init_request()
self.add_progress_system()
def solver_version(self):
"""Version of the solver."""
if server_meet_version("3.0", self._server):
return self._get_property("solver_version")
list = self._get_list()
major = list.solver_major_version
minor = list.solver_minor_version
version = str(major) + "." + str(minor)
return version
def __send_init_request(self, workflow):
if server_meet_version("3.0", self._server) \
and isinstance(workflow, workflow_pb2.RemoteCopyRequest):
request = workflow_pb2.CreateRequest()
request.remote_copy.CopyFrom(workflow)
else:
request = base_pb2.Empty()
if hasattr(workflow_pb2, "CreateRequest"):
request = workflow_pb2.CreateRequest(empty=request)
self._message = self._stub.Create(request)
def _get_physics_type(self):
"""
Returns
-------
physics_type : str
Type of the physics, such as mechanical or electric.
"""
if server_meet_version("3.0", self._server):
return self._get_property("physics_type")
intOut = self._get_list().physics_type
return result_info_pb2.PhysicsType.Name(intOut).lower()
def test_physics_type_cache(simple_bar):
ds = dpf.DataSources(simple_bar)
provider = dpf.operators.metadata.result_info_provider(data_sources=ds)
res_info = provider.outputs.result_info()
assert len(res_info._cache.cached) == 0
res_info.unit_system
assert len(res_info._cache.cached) == 1
res_info.physics_type
if server_meet_version("3.0", ds._server):
assert len(res_info._cache.cached) == 2
else:
assert len(res_info._cache.cached) == 1
def __init__(self, workflow=None, server=None):
"""Initialize the workflow by connecting to a stub."""
if server is None:
server = dpf.core._global_server()
self._server = server
self._stub = self._connect()
self._message = workflow
remote_copy_needed = server_meet_version("3.0", self._server) \
and isinstance(workflow, workflow_pb2.RemoteCopyRequest)
if isinstance(workflow, str):
self.__create_from_stream(workflow)
elif workflow is None or remote_copy_needed:
self.__send_init_request(workflow)
def get_output(self, pin=0, output_type=None):
"""Retrieve the output of the operator on the pin number.
To activate the progress bar for server version higher or equal to 3.0,
use ``my_op.progress_bar=True``
Parameters
----------
pin : int, optional
Number of the output pin. The default is ``0``.
output_type : :class:`ansys.dpf.core.common.types`, optional
Requested type of the output. The default is ``None``.
Returns
-------
type
Output of the operator.
"""
request = operator_pb2.OperatorEvaluationRequest()
request.op.CopyFrom(self._message)
request.pin = pin
if output_type:
_write_output_type_to_proto_style(output_type, request)
if server_meet_version("3.0", self._server) and self._progress_bar:
self._server._session.add_operator(self, pin, "workflow")
out_future = self._stub.Get.future(request)
while out_future.is_active():
if self._progress_bar:
self._server._session.listen_to_progress()
out = out_future.result()
else:
out = self._stub.Get(request)
return _convertOutputMessageToPythonInstance(
out, output_type, self._server)
else:
request.type = base_pb2.Type.Value("RUN")
out_future = self._stub.Get.future(request)
out_future.result()
def analysis_type(self):
"""Retrieves the analysis type.
Returns
-------
analysis_type : str
Type of the analysis, such as static or transient.
Examples
--------
>>> from ansys.dpf import core as dpf
>>> from ansys.dpf.core import examples
>>> transient = examples.download_transient_result()
>>> model = dpf.Model(transient)
>>> result_info = model.metadata.result_info
>>> result_info.analysis_type
'static'
"""
if server_meet_version("3.0", self._server):
return self._get_property("analysis_type")
intOut = self._get_list().analysis_type
return result_info_pb2.AnalysisType.Name(intOut).lower()
def main_title(self):
"""Main title."""
if server_meet_version("3.0", self._server):
return self._get_property("main_title")
return self._get_list().main_title
def product_name(self):
"""Name of the product."""
if server_meet_version("3.0", self._server):
return self._get_property("product_name")
return self._get_list().product_name
def job_name(self):
"""Name of the job."""
if server_meet_version("3.0", self._server):
return self._get_property("job_name")
return self._get_list().job_name
def user_name(self):
"""Name of the user."""
if server_meet_version("3.0", self._server):
return self._get_property("user_name")
return self._get_list().user_name
def solver_time(self):
"""Time of the solver."""
if server_meet_version("3.0", self._server):
return int(self._get_property("solver_time"))
return self._get_list().solver_time
def unit_system_name(self):
"""Name of the unit system."""
if server_meet_version("3.0", self._server):
return self._get_property("unit_system_name")
return self._get_list().unit_system_name
def n_results(self):
"""Number of results."""
if server_meet_version("3.0", self._server):
str_num = self._get_property("results_count")
return int(str_num)
return self._get_list().nresult
def __del__(self):
try:
if server_meet_version("3.0", self._server):
self._stub.Delete(self._message)
except:
pass
def unit_system(self):
"""Unit system of the result."""
if server_meet_version("3.0", self._server):
return self._get_property("unit_system_name")
val = self._get_list().unit_system
return map_unit_system[val]
def _fillConnectionRequestMessage(request, inpt, server, pin_out=0):
from ansys.dpf.core import (
collection,
cyclic_support,
data_sources,
field_base,
meshed_region,
model,
scoping,
workflow,
time_freq_support,
)
from pathlib import Path
if isinstance(inpt, str):
request.str = inpt
elif isinstance(inpt, Path):
request.str = str(inpt)
elif isinstance(inpt, bool):
request.bool = inpt
elif isinstance(inpt, int):
request.int = inpt
elif isinstance(inpt, float):
request.double = inpt
elif isinstance(inpt, list):
if all(isinstance(x, int) for x in inpt):
if server_meet_version("3.0", server):
inpt = collection.Collection.integral_collection(inpt, server)
request.collection.CopyFrom(inpt._message)
return inpt
else:
request.vint.rep_int.extend(inpt)
elif all(isinstance(x, float) for x in inpt):
if server_meet_version("3.0", server):
inpt = collection.Collection.integral_collection(inpt, server)
request.collection.CopyFrom(inpt._message)
return inpt
else:
request.vdouble.rep_double.extend(inpt)
else:
errormsg = f"input type {inpt.__class__} cannot be connected"
raise TypeError(errormsg)
elif isinstance(inpt, field_base._FieldBase):
request.field.CopyFrom(inpt._message)
elif isinstance(inpt, collection.Collection):
request.collection.CopyFrom(inpt._message)
elif isinstance(inpt, scoping.Scoping):
request.scoping.CopyFrom(inpt._message)
elif isinstance(inpt, data_sources.DataSources):
request.data_sources.CopyFrom(inpt._message)
elif isinstance(inpt, model.Model):
request.data_sources.CopyFrom(inpt.metadata.data_sources._message)
elif isinstance(inpt, meshed_region.MeshedRegion):
request.mesh.CopyFrom(inpt._message)
elif isinstance(inpt, cyclic_support.CyclicSupport):
request.cyc_support.CopyFrom(inpt._message)
elif isinstance(inpt, workflow.Workflow):
request.workflow.CopyFrom(inpt._message)
elif isinstance(inpt, time_freq_support.TimeFreqSupport):
request.time_freq_support.CopyFrom(inpt._message)
elif isinstance(inpt, Operator):
request.inputop.inputop.CopyFrom(inpt._message)
request.inputop.pinOut = pin_out
elif isinstance(inpt, Output):
request.inputop.inputop.CopyFrom(inpt._operator._message)
request.inputop.pinOut = inpt._pin
else:
errormsg = f"input type {inpt.__class__} cannot be connected"
raise TypeError(errormsg)
