dpf_extrapolate_examples (#41)

* dpf_extrapolate_examples

* fix syntax

* update

Co-authored-by: Hoang LE <[email protected]>

Author: hoangxuyenle

.ci/azure-pipelines.yml

@@ -17,8 +17,10 @@ trigger:
 
 pr:
   branches:
-    exclude:
+    include:
     - '*'
+    exclude:
+    - '*no-ci*'
 
 jobs:
 - job: Windows

ansys/dpf/core/examples/downloads.py

@@ -306,3 +306,53 @@ def download_fluent_files()->dict:
     """
     return {"cas":_download_file('fluent', 'FFF.cas.h5'),
         "dat":_download_file('fluent', 'FFF.dat.h5')}
+
+def download_extrapolation_3d_result() -> dict:
+    """Download example static results of reference and integrated points for extrapolation of 3d-element and return return the dictionary of 2 download paths.
+
+    Examples files are downloaded to a persistent cache to avoid
+    re-downloading the same file twice.
+
+    Returns
+    -------
+    dict
+        containing path to the example file of ref and path to the example file of integrated points.
+
+    Examples
+    --------
+    Download 2 example result files and return the dictionary containing 2 files
+
+    >>> from ansys.dpf.core import examples
+    >>> dict = examples.download_extrapolation_ref_result
+    >>> dict
+    {'file_ref': 'C:/Users/user/AppData/local/temp/file_ref.rst', 'file_integrated': 'C:/Users/user/AppData/local/temp/file.rst'}
+
+    """
+    dict={'file_ref': _download_file('extrapolate', 'file_ref.rst'), 'file_integrated': _download_file('extrapolate', 'file.rst')}
+  
+    return dict
+
+def download_extrapolation_2d_result() -> dict:
+    """Download example static results of reference and integrated points for extrapolation of 2d-element and return the dictionary of 2 download paths.
+
+    Examples files are downloaded to a persistent cache to avoid
+    re-downloading the same file twice.
+
+    Returns
+    -------
+    dict
+        containing path to the example file of ref and path to the example file of integrated points.
+
+     Examples
+    --------
+    Download 2 example result files and return the dictionary containing 2 files
+
+    >>> from ansys.dpf.core import examples
+    >>> dict = examples.download_extrapolation_ref_result
+    >>> dict
+    {'file_ref': 'C:/Users/user/AppData/local/temp/extrapolate_2d_ref.rst', 'file_integrated': 'C:/Users/user/AppData/local/temp/extrapolate_2d.rst'}
+
+    """
+    dict={'file_ref': _download_file('extrapolate', 'extrapolate_2d_ref.rst'), 'file_integrated': _download_file('extrapolate', 'extrapolate_2d.rst')}
+  
+    return dict

examples/03-advanced/04-extrapolation_stress_3d.py

@@ -0,0 +1,117 @@
+"""
+.. _extrapolation_test_stress_3Delement:
+
+Extrapolation Method for stress result of 3D-element
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This example shows how to compute the nodal components stress from Gaussian points (integration points) for 3D-element by using the method of extrapolation.
+Extrapolating results available at Gauss or quadrature points to nodal points for a field or fields container. The available elements are : linear quadrangle, parabolic quadrangle, linear hexagonal, quadratic hexagonal, linear tetrahedral, quadratic tetrahedral. 
+
+1st step : get the data source's analyse of integration points(this file was add the commands APDL "EREXS, NO").
+
+2nd step: using operator of extrapolation to compute the nodal stress.
+
+3rd step: get nodal stress result from data source's analyse reference. The analyse was computed by ANSYS Mechanical APDL.
+
+4th step: compare the results between nodal stress from data source ref and nodal stress computed by Extrapolation Method.
+
+"""
+
+from ansys.dpf import core as dpf
+from ansys.dpf.core import examples
+from ansys.dpf.core import operators 
+
+
+###############################################################################
+# Get the data source's analyse of integration points and data source's analyse reference
+datafile= examples.download_extrapolation_3d_result()
+
+# integration points (Gaussian points)
+data_integration_points=datafile['file_integrated']
+data_sources_integration_points = dpf.DataSources(data_integration_points)
+
+# reference
+dataSourceref=datafile['file_ref']
+data_sources_ref = dpf.DataSources(dataSourceref)
+
+# get the mesh 
+model = dpf.Model(data_integration_points)
+mesh = model.metadata.meshed_region
+
+# operator instantiation scoping
+op_scoping = dpf.operators.scoping.splitted_on_property_type() # operator instantiation
+op_scoping.inputs.mesh.connect(mesh)
+op_scoping.inputs.requested_location.connect("Elemental")
+mesh_scoping = op_scoping.outputs.mesh_scoping()
+
+###############################################################################
+# Extrapolation from integration points for stress result
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# In this example we compute nodal component stress result from integration points's stress by using operator gauss_to_node_fc
+
+# Create stress operator to get stress result of integration points
+stressop=dpf.operators.result.stress()
+stressop.inputs.data_sources.connect(data_sources_integration_points)
+stress=stressop.outputs.fields_container()
+
+###############################################################################
+# Nodal stress result of integration points: 
+###############################################################################
+# The command "ERESX,NO" in Mechanical APDL is used to copy directly the gaussian (integration) points results to the nodes, instead of the results at nodes or elements (which are interpolation of results at a few gauss points).
+# The following plot shows the nodal values which are the averaged values of stresses at each node. The value shown at the node is the average of the stresses from the gaussian points of each element that it belongs to. 
+
+# plot
+stress_nodal_op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
+stress_nodal_op.inputs.fields_container.connect(stress)
+mesh.plot(stress_nodal_op.outputs.fields_container())
+
+
+###############################################################################
+# Create operator gauss_to_node_fc and compute nodal component stress by applying Extrapolation Method
+
+ex_stress = dpf.operators.averaging.gauss_to_node_fc()
+# connect mesh
+ex_stress.inputs.mesh.connect(mesh)
+# connect fields container stress
+ex_stress.inputs.fields_container.connect(stress)
+# get output
+fex=ex_stress.outputs.fields_container()
+
+###############################################################################
+# Stress result of reference ANSYS Workbench
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+# Stress from file dataSourceref
+stressop_ref=dpf.operators.result.stress()
+stressop_ref.inputs.data_sources.connect(data_sources_ref)
+stressop_ref.inputs.mesh_scoping.connect(mesh_scoping)
+stress_ref=stressop_ref.outputs.fields_container()
+
+###############################################################################
+# Plot
+#~~~~~~~~~~
+# Showing plots of Extrapolation's stress result and reference's stress result
+
+# extrapolation
+fex_nodal_op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
+fex_nodal_op.inputs.fields_container.connect(fex)
+mesh.plot(fex_nodal_op.outputs.fields_container())
+# reference
+stress_ref_nodal_op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
+stress_ref_nodal_op.inputs.fields_container.connect(stress_ref)
+mesh.plot(stress_ref_nodal_op.outputs.fields_container())
+
+###############################################################################
+# Comparison
+#~~~~~~~~~~~~
+# Compare the stress result computed by extrapolation and reference's result.
+# Check if two fields container are identical. 
+# Maximum tolerance gap between to compared values: 1e-2.
+# Smallest value which will be considered during the comparison step : all the abs(values) in field less than 1e-8 is considered as null
+
+# operator AreFieldsIdentical_fc
+op = dpf.operators.logic.identical_fc()
+op.inputs.fields_containerA.connect(fex)
+op.inputs.fields_containerB.connect(stress_ref)
+op.inputs.tolerance.connect(1.0e-8)
+op.inputs.small_value.connect(0.01)
+op.outputs.boolean()

examples/03-advanced/05-extrapolation_strain_2d.py

@@ -0,0 +1,110 @@
+"""
+.. _extrapolation_test_strain_2Delement:
+
+Extrapolation Method for strain result of 2D-element
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This example shows how to compute the nodal components elastic strain from Gaussian points (integration points) for 2D-element by using the method of extrapolation.
+Extrapolating results available at Gauss or quadrature points to nodal points for a field or fields container. The available elements are : linear quadrangle, parabolic quadrangle, linear hexagonal, quadratic hexagonal, linear tetrahedral, quadratic tetrahedral. 
+
+1st step : get the data source's analyse of integration points(this file was add the commands APDL "EREXS, NO").
+
+2nd step: using operator of extrapolation to compute the nodal elastic strain.
+
+3rd step: get nodal elastic strain result from data source's analyse reference. The analyse was computed by ANSYS Mechanical APDL.
+
+4th step: compare the results between nodal elastic strain from data source ref and nodal strain computed by Extrapolation Method.
+
+"""
+
+from ansys.dpf import core as dpf
+from ansys.dpf.core import examples
+from ansys.dpf.core import operators 
+
+
+###############################################################################
+# Get the data source's analyse of integration points and data source's analyse reference
+datafile= examples.download_extrapolation_2d_result()
+
+# integration points (Gaussian points)
+data_integration_points=datafile['file_integrated']
+data_sources_integration_points = dpf.DataSources(data_integration_points)
+
+# reference
+dataSourceref=datafile['file_ref']
+data_sources_ref = dpf.DataSources(dataSourceref)
+
+# get the mesh 
+model = dpf.Model(data_integration_points)
+mesh = model.metadata.meshed_region
+
+###############################################################################
+# Extrapolation from integration points for elastic strain result
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# In this example we compute nodal component elastic strain results from integration points's elastic strain by using operator gauss_to_node_fc
+
+# Create elastic strain operator to get strain result of integration points
+strainop=dpf.operators.result.elastic_strain()
+strainop.inputs.data_sources.connect(data_sources_integration_points)
+strain=strainop.outputs.fields_container()
+
+###############################################################################
+# Nodal elastic strain result of integration points: 
+###############################################################################
+# The command "ERESX,NO" in Mechanical APDL is used to copy directly the gaussian (integration) points results to the nodes, instead of the results at nodes or elements (which are interpolation of results at a few gauss points).
+# The following plot shows the nodal values which are the averaged values of elastic strain at each node. The value shown at the node is the average of the elastic strains from the gaussian points of each element that it belongs to. 
+
+# plot
+strain_nodal_op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
+strain_nodal_op.inputs.fields_container.connect(strain)
+mesh.plot(strain_nodal_op.outputs.fields_container())
+
+
+###############################################################################
+# Create operator gauss_to_node_fc and compute nodal component elastic strain by applying Extrapolation Method
+
+ex_strain = dpf.operators.averaging.gauss_to_node_fc()
+# connect mesh
+ex_strain.inputs.mesh.connect(mesh)
+# connect fields container elastic strain
+ex_strain.inputs.fields_container.connect(strain)
+# get output
+fex=ex_strain.outputs.fields_container()
+
+###############################################################################
+# Elastic strain result of reference ANSYS Workbench
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+# Strain from file dataSourceref
+strainop_ref=dpf.operators.result.elastic_strain()
+strainop_ref.inputs.data_sources.connect(data_sources_ref)
+strain_ref=strainop_ref.outputs.fields_container()
+
+###############################################################################
+# Plot
+# ~~~~~~~~~~
+# Showing plots of Extrapolation's elastic strain result and reference's elastic strain result
+
+# extrapolation
+fex_nodal_op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
+fex_nodal_op.inputs.fields_container.connect(fex)
+mesh.plot(fex_nodal_op.outputs.fields_container())
+# reference
+strain_ref_nodal_op = dpf.operators.averaging.elemental_nodal_to_nodal_fc()
+strain_ref_nodal_op.inputs.fields_container.connect(strain_ref)
+mesh.plot(strain_ref_nodal_op.outputs.fields_container())
+
+###############################################################################
+# Comparison
+# ~~~~~~~~~~~~
+# Compare the elastic strain result computed by extrapolation and reference's result.
+# Check if two fields container are identical. 
+# Maximum tolerance gap between to compared values: 1e-3.
+# Smallest value which will be considered during the comparison step : all the abs(values) in field less than 1e-14 is considered as null
+
+# operator AreFieldsIdentical_fc
+op = dpf.operators.logic.identical_fc()
+op.inputs.fields_containerA.connect(fex)
+op.inputs.fields_containerB.connect(strain_ref)
+op.inputs.tolerance.connect(1.0e-14)
+op.inputs.small_value.connect(0.001)
+op.outputs.boolean()