def test_multi_process_transparent_api_connect_local_op_remote_workflow():
files = examples.download_distributed_files()
workflows = []
for i in files:
wf = core.Workflow(server=local_servers[i])
op = ops.result.displacement(server=local_servers[i])
average = core.operators.math.norm_fc(op, server=local_servers[i])
wf.add_operators([op, average])
wf.set_output_name("distrib" + str(i),
average.outputs.fields_container)
wf.set_input_name("ds", op.inputs.data_sources)
workflows.append(wf)
local_wf = core.Workflow()
merge = ops.utility.merge_fields_containers()
min_max = ops.min_max.min_max_fc(merge)
local_wf.add_operator(merge)
local_wf.add_operator(min_max)
local_wf.set_output_name("tot_output", min_max.outputs.field_max)
for i, wf in enumerate(workflows):
data_sources1 = core.DataSources(files[i])
forward = ops.utility.forward(data_sources1)
wf.connect("ds", forward, 0)
local_wf.set_input_name("distrib" + str(i), merge, i)
local_wf.connect_with(wf)
max = local_wf.get_output("tot_output", core.types.field)
assert np.allclose(max.data, [10.03242272])
def test_multi_process_transparent_api_create_on_local_remote_ith_address_workflow(
):
files = examples.download_distributed_files()
wf = core.Workflow()
op = ops.result.displacement()
average = core.operators.math.norm_fc(op)
wf.add_operators([op, average])
wf.set_output_name("distrib", average.outputs.fields_container)
wf.set_input_name("ds", op.inputs.data_sources)
local_wf = core.Workflow()
merge = ops.utility.merge_fields_containers()
min_max = ops.min_max.min_max_fc(merge)
local_wf.add_operator(merge)
local_wf.add_operator(min_max)
local_wf.set_output_name("tot_output", min_max.outputs.field_max)
for i in files:
data_sources1 = core.DataSources(files[i])
remote_wf = wf.create_on_other_server(ip=local_servers[i].ip,
port=local_servers[i].port)
remote_wf.connect("ds", data_sources1)
local_wf.set_input_name("distrib" + str(i), merge, i)
local_wf.connect_with(remote_wf, ("distrib", "distrib" + str(i)))
max = local_wf.get_output("tot_output", core.types.field)
assert np.allclose(max.data, [10.03242272])
def test_multi_process_chain_remote_workflow():
files = examples.download_distributed_files()
wf = core.Workflow()
op = ops.result.displacement()
average = core.operators.math.norm_fc(op)
wf.add_operators([op, average])
wf.set_input_name("data_sources", op.inputs.data_sources)
wf.set_output_name("distrib", average.outputs.fields_container)
workflows = []
for i in files:
data_sources1 = core.DataSources(files[i])
grpc_stream_provider = ops.metadata.streams_provider()
grpc_data_sources = core.DataSources()
grpc_data_sources.set_result_file_path(
local_servers[i].ip + ":" + str(local_servers[i].port), "grpc")
grpc_stream_provider.inputs.data_sources(grpc_data_sources)
remote_workflow_prov = core.Operator("remote_workflow_instantiate")
remote_workflow_prov.connect(3, grpc_stream_provider, 0)
remote_workflow_prov.connect(0, wf)
remote_workflow = remote_workflow_prov.get_output(
0, core.types.workflow)
remote_workflow.connect("data_sources", data_sources1)
workflows.append(remote_workflow)
local_wf = core.Workflow()
merge = ops.utility.merge_fields_containers()
min_max = ops.min_max.min_max_fc(merge)
local_wf.add_operator(merge)
local_wf.add_operator(min_max)
local_wf.set_output_name("tot_output", min_max.outputs.field_max)
for i, wf in enumerate(workflows):
local_wf.set_input_name("distrib" + str(i), merge, i)
grpc_stream_provider = ops.metadata.streams_provider()
grpc_data_sources = core.DataSources()
grpc_data_sources.set_result_file_path(
local_servers[2].ip + ":" + str(local_servers[2].port), "grpc")
grpc_stream_provider.inputs.data_sources(grpc_data_sources)
remote_workflow_prov = core.Operator("remote_workflow_instantiate")
remote_workflow_prov.connect(3, grpc_stream_provider, 0)
remote_workflow_prov.connect(0, local_wf)
remote_workflow = remote_workflow_prov.get_output(0, core.types.workflow)
for i, wf in enumerate(workflows):
remote_workflow.connect_with(wf, ("distrib", "distrib" + str(i)))
max = remote_workflow.get_output("tot_output", core.types.field)
assert np.allclose(max.data, [10.03242272])
remote_servers = [
dpf.start_local_server(as_global=False),
dpf.start_local_server(as_global=False)
]
ips = [remote_server.ip for remote_server in remote_servers]
ports = [remote_server.port for remote_server in remote_servers]
###############################################################################
# Print the ips and ports
print("ips:", ips)
print("ports:", ports)
###############################################################################
# Here we show how we could send files in temporary directory if we were not
# in shared memory
files = examples.download_distributed_files()
server_file_paths = [
dpf.upload_file_in_tmp_folder(files[0], server=remote_servers[0]),
dpf.upload_file_in_tmp_folder(files[1], server=remote_servers[1])
]
###############################################################################
# Create the operators on the servers
# ~~~~~~~~~~~~~~~~~~~~~~~~~~
# On each server we create two new operators for 'displacement' and 'norm'
# computations and define their data sources. The displacement operator
# receives data from the data file in its respective server. And the norm
# operator, being chained to the displacement operator, receives input from the
# output of this one.
remote_operators = []
for i, server in enumerate(remote_servers):
Solvers usually solve analysis with distributed architecture. In that case one file is written by spatial or temporal domains. The capability of reading one result in distributed files has been implemented in DPF. This allows to skip the merging of files solver side which is time consuming and often duplicates the memory used. """ from ansys.dpf import core as dpf from ansys.dpf.core import examples ############################################################################### # Create the data sources # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # First create a data sources with one result file by domain distributed_file_path = examples.download_distributed_files() data_sources = dpf.DataSources() data_sources.set_domain_result_file_path(distributed_file_path[0], 0) data_sources.set_domain_result_file_path(distributed_file_path[1], 1) ############################################################################### # Compute displacements # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Once the file architecture is put in the data sources, # computing displacements with or without domain has the exact same syntax. # DPF reads parts of the result on each domain and remerge the results in # the outputs fields. The output will have no difference when using combined # or distributed files model = dpf.Model(data_sources) disp = model.results.displacement.on_all_time_freqs.eval()