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])
def test_plot_meshes_container_1(multishells): model = core.Model(multishells) mesh = model.metadata.meshed_region split_mesh_op = core.Operator("split_mesh") split_mesh_op.connect(7, mesh) split_mesh_op.connect(13, "mat") meshes_cont = split_mesh_op.get_output(0, core.types.meshes_container) disp_op = core.Operator("U") disp_op.connect(7, meshes_cont) ds = core.DataSources(multishells) disp_op.connect(4, ds) disp_fc = disp_op.outputs.fields_container() meshes_cont.plot(disp_fc)
def test_simple_remote_workflow(simple_bar, local_server): data_sources1 = core.DataSources(simple_bar) wf = core.Workflow() op = ops.result.displacement(data_sources=data_sources1) average = core.operators.math.norm_fc(op) wf.add_operators([op, average]) wf.set_output_name("out", average.outputs.fields_container) local_wf = core.Workflow() min_max = ops.min_max.min_max_fc() local_wf.add_operator(min_max) local_wf.set_input_name("in", min_max.inputs.fields_container) local_wf.set_output_name("tot_output", min_max.outputs.field_max) grpc_stream_provider = ops.metadata.streams_provider() grpc_data_sources = core.DataSources() grpc_data_sources.set_result_file_path( local_server.ip + ":" + str(local_server.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) local_wf.connect_with(remote_workflow, ("out", "in")) max = local_wf.get_output("tot_output", core.types.field) assert np.allclose(max.data, [2.52368345e-05])
def create_mesh_and_field_mapped(multishells): # get metadata model = core.Model(multishells) mesh = model.metadata.meshed_region disp_fc = model.results.displacement().outputs.fields_container() field = disp_fc[0] # coordinates field to map coordinates = [[-0.02, 0.006, 0.014], [-0.02, 0.006, 0.012], [-0.018, 0.006, 0.012], [-0.018, 0.006, 0.014]] field_coord = core.Field() field_coord.location = core.locations.nodal field_coord.data = coordinates scoping = core.Scoping() scoping.location = core.locations.nodal scoping.ids = list(range(1, len(coordinates) + 1)) field_coord.scoping = scoping # mapping operator mapping_operator = core.Operator("mapping") mapping_operator.inputs.fields_container.connect(disp_fc) mapping_operator.inputs.coordinates.connect(field_coord) mapping_operator.inputs.mesh.connect(mesh) mapping_operator.inputs.create_support.connect(True) fields_mapped = mapping_operator.outputs.fields_container() # mesh path assert len(fields_mapped) == 1 field_m = fields_mapped[0] mesh_m = field_m.meshed_region return field, field_m, mesh, mesh_m
def test_cff(cff_data_sources): m = dpf.Model(cff_data_sources) assert m.metadata.meshed_region.nodes.n_nodes == 1430 op = dpf.Operator("cff::cas::SV_DENSITY") op.connect(4, m.metadata.data_sources) fc = op.get_output(0, dpf.types.fields_container) assert len(fc[0]) == 1380
def test_plot_meshes_container_only(multishells): model = core.Model(multishells) mesh = model.metadata.meshed_region split_mesh_op = core.Operator("split_mesh") split_mesh_op.connect(7, mesh) split_mesh_op.connect(13, "mat") meshes_cont = split_mesh_op.get_output(0, core.types.meshes_container) meshes_cont.plot()
def test_eng(engineering_data_sources): dpf.load_library("composite_operators.dll", "compo") dpf.load_library("Ans.Dpf.EngineeringData.dll", "eng") m = dpf.Model(engineering_data_sources) stress_op = dpf.operators.result.stress() stress_op.inputs.data_sources.connect(engineering_data_sources) result_info_provider = dpf.operators.metadata.result_info_provider() result_info_provider.inputs.data_sources.connect(engineering_data_sources) mat_support_operator = dpf.operators.metadata.material_support_provider() mat_support_operator.inputs.data_sources.connect(engineering_data_sources) ans_mat_operator = dpf.Operator("eng_data::ans_mat_material_provider") ans_mat_operator.connect(0, mat_support_operator, 0) ans_mat_operator.connect(1, result_info_provider, 0) ans_mat_operator.connect(4, engineering_data_sources) field_variable_provider = dpf.Operator( "composite::inistate_field_variables_provider") field_variable_provider.connect(4, engineering_data_sources) field_variable_provider.inputs.mesh.connect(m.metadata.mesh_provider) field_variable_provider.run()
def test_hdf5_ellipsis_any_pins(simple_bar, tmpdir): tmp_path = str(tmpdir.join("hdf5.h5")) model = core.Model(simple_bar) u = model.results.displacement() s = model.operator("S") op = core.Operator("serialize_to_hdf5") op.inputs.file_path.connect(tmp_path) op.inputs.data1.connect(u.outputs) op.inputs.data2.connect(s.outputs) assert len(op.inputs._connected_inputs) == 3
def test_plotter_add_mesh(multishells): model = core.Model(multishells) mesh = model.metadata.meshed_region split_mesh_op = core.Operator("split_mesh") split_mesh_op.connect(7, mesh) split_mesh_op.connect(13, "mat") meshes_cont = split_mesh_op.get_output(0, core.types.meshes_container) from ansys.dpf.core.plotter import DpfPlotter pl = DpfPlotter() for i in range(len(meshes_cont) - 10): pl.add_mesh(meshes_cont[i]) pl.show_figure()
def test_plot_meshes_container_2(multishells): from ansys.dpf import core model = core.Model(multishells) mesh = model.metadata.meshed_region split_mesh_op = core.Operator("split_mesh") split_mesh_op.connect(7, mesh) split_mesh_op.connect(13, "mat") meshes_cont = split_mesh_op.get_output(0, core.types.meshes_container) disp_op = core.Operator("U") disp_op.connect(7, meshes_cont) ds = core.DataSources(multishells) disp_op.connect(4, ds) disp_fc = disp_op.outputs.fields_container() meshes_cont_2 = core.MeshesContainer() meshes_cont_2.labels = meshes_cont.labels disp_fc_2 = core.FieldsContainer() disp_fc_2.labels = meshes_cont.labels for i in range(len(meshes_cont) - 10): lab = meshes_cont.get_label_space(i) meshes_cont_2.add_mesh(lab, meshes_cont.get_mesh(lab)) disp_fc_2.add_field(lab, disp_fc.get_field(lab)) meshes_cont_2.plot(disp_fc_2)
def test_field_shell_plot_scoping_elemental(multishells): model = core.Model(multishells) mesh = model.metadata.meshed_region stress = model.results.stress() scoping = core.Scoping() scoping.location = "Elemental" l = list(range(3000, 4500)) scoping.ids = l stress.inputs.mesh_scoping.connect(scoping) avg = core.Operator("to_elemental_fc") avg.inputs.fields_container.connect(stress.outputs.fields_container) s = avg.outputs.fields_container() f = s[1] f.plot(shell_layers=core.shell_layers.top)
def test_remote_workflow_info(local_server): 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) grpc_stream_provider = ops.metadata.streams_provider() grpc_data_sources = core.DataSources() grpc_data_sources.set_result_file_path( local_server.ip + ":" + str(local_server.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) assert "data_sources" in remote_workflow.input_names assert "distrib" in remote_workflow.output_names
cyc = examples.download_multi_stage_cyclic_result() model = dpf.Model(cyc) print(model) ############################################################################### # Expand displacement results # ~~~~~~~~~~~~~~~~~~~~~~~~~~~ # In this example we expand displacement results, by default on all # nodes and the first time step. # Create displacement cyclic operator UCyc = model.results.displacement() UCyc.inputs.read_cyclic(2) # expand the displacements and get a total deformation nrm = dpf.Operator("norm_fc") nrm.inputs.connect(UCyc.outputs) fields = nrm.outputs.fields_container() # # get the expanded mesh mesh_provider = model.metadata.mesh_provider mesh_provider.inputs.read_cyclic(2) mesh = mesh_provider.outputs.mesh() # # plot the expanded result on the expanded mesh mesh.plot(fields) ############################################################################### # Expand stresses at a given time step # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# use component wise divide to averaged the stress by the volume divide = ops.math.component_wise_divide(seqvsum, volsum) divide.run() ############################################################################### # Plot elemental seqv and volume averaged elemental seqv # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ mesh.plot(values_to_sum_field) mesh.plot(divide.outputs.field()) ############################################################################### # Use the Operator instead # ~~~~~~~~~~~~~~~~~~~~~~~~~ # An operator with the same algorithm has been implemented s_fc = s.outputs.fields_container() single_field_vol_fc = dpf.fields_container_factory.over_time_freq_fields_container( [vol_field]) single_field_fc = dpf.fields_container_factory.over_time_freq_fields_container( [values_to_sum_field]) op = dpf.Operator("volume_stress") op.inputs.scoping.connect(nodes) op.inputs.stress_fields.connect(single_field_fc) op.inputs.volume_fields(single_field_vol_fc) op.inputs.volume(volume_check * 10.0) out = op.get_output(0, dpf.types.field) mesh.plot(out)
# Create a total displacement operator and set its time scoping to # the entire time freq support and its nodes scoping into a user defined nodes. disp_op = ops.result.raw_displacement(data_sources=model) time_ids = list(range(1, model.metadata.time_freq_support.n_sets + 1)) # define nodal scoping nodes = dpf.Scoping() nodes.ids = [2, 18] # connect the frequencies and the nodes scopings to the result # provider operator disp_op.inputs.mesh_scoping.connect(nodes) disp_op.inputs.time_scoping.connect(time_ids) # extract Rz component using the component selector operator comp = dpf.Operator("component_selector_fc") comp.inputs.connect(disp_op.outputs) comp.inputs.component_number.connect(5) # Compute the multi-harmonic response based on Rz and a set of RPMs rpms = dpf.Scoping() rpms.ids = [1, 2, 3] fft = ops.math.fft_multi_harmonic_minmax() fft.inputs.connect(comp.outputs) fft.inputs.rpm_scoping.connect(rpms) fields = fft.outputs.field_max() len(fields) # one multi-harmonic field response per node
############################################################################### # Create a model object to establish a connection with an # example result file: model = dpf.Model(examples.static_rst) print(model) ############################################################################### # Next, create a raw displacement operator ``"U"``. Each operator # contains ``input`` and ``output`` pins that can be connected to # various sources to include other operators. This allows operators # to be "chained" to allow for highly efficient operations. # # To print out the available inputs and outputs of the # displacement operator: disp_op = dpf.Operator("U") print(disp_op.inputs) print(disp_op.outputs) ############################################################################### # Compute the Maximum Normalized Displacement # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # This example demonstrate how to chain various operators. It connects the input # of the operator to the data sources contained within the ``model`` object and # then the maximum of the norm of the operator. # Connect to the data sources of the model. disp_op.inputs.data_sources.connect(model.metadata.data_sources) # Create a field container norm operator and connect it to the # displacement operator to chain the operators.
def plot_contour(self, field_or_fields_container, notebook=None, shell_layers=None, off_screen=None, show_axes=True, meshed_region=None, **kwargs): """Plot the contour result on its mesh support. You cannot plot a fields container containing results at several time steps. Parameters ---------- field_or_fields_container : dpf.core.Field or dpf.core.FieldsContainer Field or field container that contains the result to plot. notebook : bool, optional Whether to plot a static image within an iPython notebook if available. The default is `None`, in which case an attempt is made to plot a static imaage within an iPython notebook. When ``False``, a plot external to the notebook is generated with an interactive window. When ``True``, a plot is always generated within a notebook. shell_layers : core.shell_layers, optional Enum used to set the shell layers if the model to plot contains shell elements. off_screen : bool, optional Whether to render off screen, which is useful for automated screenshots. The default is ``None``. show_axes : bool, optional Whether to show a VTK axes widget. The default is ``True``. **kwargs : optional Additional keyword arguments for the plotter. For more information, see ``help(pyvista.plot)``. """ if not sys.warnoptions: import warnings warnings.simplefilter("ignore") if isinstance(field_or_fields_container, (dpf.core.Field, dpf.core.FieldsContainer)): fields_container = None if isinstance(field_or_fields_container, dpf.core.Field): fields_container = dpf.core.FieldsContainer( server=field_or_fields_container._server) fields_container.add_label(DefinitionLabels.time) fields_container.add_field({DefinitionLabels.time: 1}, field_or_fields_container) elif isinstance(field_or_fields_container, dpf.core.FieldsContainer): fields_container = field_or_fields_container else: raise TypeError("Only field or fields_container can be plotted.") # pre-loop to check if the there are several time steps labels = fields_container.get_label_space(0) if DefinitionLabels.complex in labels.keys(): raise dpf_errors.ComplexPlottingError if DefinitionLabels.time in labels.keys(): first_time = labels[DefinitionLabels.time] for i in range(1, len(fields_container)): label = fields_container.get_label_space(i) if label[DefinitionLabels.time] != first_time: raise dpf_errors.FieldContainerPlottingError if meshed_region is not None: mesh = meshed_region else: mesh = self._mesh # get mesh scoping location = None component_count = None name = None # pre-loop to get location and component count for field in fields_container: if len(field.data) != 0: location = field.location component_count = field.component_count name = field.name.split("_")[0] break if location == locations.nodal: mesh_location = mesh.nodes elif location == locations.elemental: mesh_location = mesh.elements else: raise ValueError( "Only elemental or nodal location are supported for plotting.") # pre-loop: check if shell layers for each field, if yes, set the shell layers changeOp = core.Operator("change_shellLayers") for field in fields_container: shell_layer_check = field.shell_layers if shell_layer_check in [ eshell_layers.topbottom, eshell_layers.topbottommid, ]: changeOp.inputs.fields_container.connect(fields_container) sl = eshell_layers.top if shell_layers is not None: if not isinstance(shell_layers, eshell_layers): raise TypeError( "shell_layer attribute must be a core.shell_layers instance." ) sl = shell_layers changeOp.inputs.e_shell_layer.connect( sl.value) # top layers taken fields_container = changeOp.get_output( 0, core.types.fields_container) break # Merge field data into a single array if component_count > 1: overall_data = np.full((len(mesh_location), component_count), np.nan) else: overall_data = np.full(len(mesh_location), np.nan) for field in fields_container: ind, mask = mesh_location.map_scoping(field.scoping) overall_data[ind] = field.data[mask] # create the plotter and add the meshes background = kwargs.pop("background", None) cpos = kwargs.pop("cpos", None) return_cpos = kwargs.pop("return_cpos", None) # plotter = pv.Plotter(notebook=notebook, off_screen=off_screen) if notebook is not None: self._internal_plotter._plotter.notebook = notebook if off_screen is not None: self._internal_plotter._plotter.off_screen = off_screen # add meshes kwargs.setdefault("show_edges", True) kwargs.setdefault("nan_color", "grey") kwargs.setdefault("stitle", name) text = kwargs.pop('text', None) if text is not None: self._internal_plotter._plotter.add_text(text, position='lower_edge') self._internal_plotter._plotter.add_mesh(mesh.grid, scalars=overall_data, **kwargs) if background is not None: self._internal_plotter._plotter.set_background(background) if cpos is not None: self._internal_plotter._plotter.camera_position = cpos # show result if show_axes: self._internal_plotter._plotter.add_axes() if return_cpos is None: return self._internal_plotter._plotter.show() else: import pyvista as pv pv_version = pv.__version__ version_to_reach = '0.32.0' meet_ver = meets_version(pv_version, version_to_reach) if meet_ver: return self._internal_plotter._plotter.show( return_cpos=return_cpos) else: txt = """To use the return_cpos option, please upgrade your pyvista module with a version higher than """ txt += version_to_reach raise core.errors.DpfVersionNotSupported(version_to_reach, txt)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # define stress expansion operator and request stresses at time set = 8 scyc_op = model.operator("mapdl::rst::S_cyclic") scyc_op.inputs.read_cyclic(2) scyc_op.inputs.time_scoping.connect([8]) # request the results averaged on the nodes scyc_op.inputs.requested_location.connect("Nodal") # connect the base mesh and the expanded mesh, to avoid rexpanding the mesh scyc_op.inputs.sector_mesh.connect(model.metadata.meshed_region) # scyc_op.inputs.expanded_meshed_region.connect(mesh) # request equivalent von mises operator and connect it to stress operator eqv = dpf.Operator("eqv_fc") eqv.inputs.connect(scyc_op.outputs) # expand the results and get stress eqv fields = eqv.outputs.fields_container() # plot the expanded result on the expanded mesh # mesh.plot(fields[0]) ############################################################################### # Expand stresses at given sectors # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # define stress expansion operator and request stresses at time set = 8 scyc_op = model.operator("mapdl::rst::S_cyclic") scyc_op.inputs.read_cyclic(2)
def test_hdf5_loaded(): op = core.Operator("serialize_to_hdf5") assert op.inputs is not None
def create_mesh_and_field_mapped_2(multishells): # get metadata model = core.Model(multishells) mesh = model.metadata.meshed_region disp_fc = model.results.displacement().outputs.fields_container() field = disp_fc[0] # coordinates field to map coordinates = [[-0.0195, 0.006, -0.0025]] for i in range(1, 101): coord_copy = [] coord_copy.append(coordinates[0][0]) coord_copy.append(coordinates[0][1]) coord_copy.append(coordinates[0][2]) coord_copy[0] = coord_copy[0] + i * 0.0003 coordinates.append(coord_copy) ref = [-0.0155, 0.00600634, -0.0025] coordinates.append(ref) for i in range(1, 101): coord_copy = [] coord_copy.append(ref[0]) coord_copy.append(ref[1]) coord_copy.append(ref[2]) coord_copy[0] = coord_copy[0] + i * 0.0003 coordinates.append(coord_copy) ref = [-0.0125, 0.00600507, -0.0025] coordinates.append(ref) for i in range(1, 101): coord_copy = [] coord_copy.append(ref[0]) coord_copy.append(ref[1]) coord_copy.append(ref[2]) coord_copy[0] = coord_copy[0] + i * 0.0003 coordinates.append(coord_copy) ref = [-0.0125, 0.00600444, -0.0025] coordinates.append(ref) for i in range(1, 101): coord_copy = [] coord_copy.append(ref[0]) coord_copy.append(ref[1]) coord_copy.append(ref[2]) coord_copy[0] = coord_copy[0] + i * 0.0003 coordinates.append(coord_copy) field_coord = core.Field() field_coord.location = core.locations.nodal field_coord.data = coordinates scoping = core.Scoping() scoping.location = core.locations.nodal scoping.ids = list(range(1, len(coordinates) + 1)) field_coord.scoping = scoping # mapping operator mapping_operator = core.Operator("mapping") mapping_operator.inputs.fields_container.connect(disp_fc) mapping_operator.inputs.coordinates.connect(field_coord) mapping_operator.inputs.mesh.connect(mesh) mapping_operator.inputs.create_support.connect(True) fields_mapped = mapping_operator.outputs.fields_container() # mesh path assert len(fields_mapped) == 1 field_m = fields_mapped[0] mesh_m = field_m.meshed_region return field, field_m, mesh, mesh_m
"Ans.Dpf.Hdf5.dll", ] local_dir = os.path.dirname(os.path.abspath(__file__)) TARGET_PATH = os.path.join(local_dir, os.pardir, "ansys", "dpf", "core", "operators") files = glob.glob(os.path.join(TARGET_PATH, "*")) for f in files: if Path(f).stem == "specification": continue try: if os.path.isdir(f): shutil.rmtree(f) else: os.remove(f) except: pass core.start_local_server() code_gen = core.Operator("python_generator") code_gen.connect(1, TARGET_PATH) for lib in LIB_TO_GENERATE: code_gen.connect(0, lib) if lib != LIB_TO_GENERATE[0]: code_gen.connect(2, False) else: code_gen.connect(2, True) code_gen.run() time.sleep(0.1) core.SERVER.shutdown()
# Create displacement cyclic operator UCyc = dpf.operators.result.cyclic_expanded_displacement() UCyc.inputs.data_sources(model.metadata.data_sources) # Select the sectors to expand on the first stage UCyc.inputs.sectors_to_expand([0, 1, 2]) # Or select the sectors to expand stage by stage sectors_scopings = dpf.ScopingsContainer() sectors_scopings.labels = ["stage"] sectors_scopings.add_scoping({"stage": 0}, dpf.Scoping(ids=[0, 1, 2])) sectors_scopings.add_scoping({"stage": 1}, dpf.Scoping(ids=[0, 1, 2, 3, 4, 5, 6])) UCyc.inputs.sectors_to_expand(sectors_scopings) # expand the displacements and get a total deformation nrm = dpf.Operator("norm_fc") nrm.inputs.connect(UCyc.outputs) fields = nrm.outputs.fields_container() # # get the expanded mesh mesh_provider = model.metadata.mesh_provider mesh_provider.inputs.read_cyclic(2) mesh = mesh_provider.outputs.mesh() ############################################################################### # plot the expanded result on the expanded mesh # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ mesh.plot(fields) ############################################################################### # Choose to expand only some sectors for the mesh