Add deformations for cad files

ndem0 · ndem0 · commit f325672e2b7a · 2020-05-15T17:00:26.000+02:00
diff --git a/pygem/cad/__init__.py b/pygem/cad/__init__.py
@@ -16,3 +16,6 @@
 from .stephandler import StepHandler
 from .igeshandler import IgesHandler
 from .ffd import FFD
+from .rbf import RBF
+from .idw import IDW
+from .cad_deformation import CADDeformation
diff --git a/pygem/cad/cad_deformation.py b/pygem/cad/cad_deformation.py
diff --git a/pygem/cad/ffd.py b/pygem/cad/ffd.py
diff --git a/pygem/cad/idw.py b/pygem/cad/idw.py
@@ -0,0 +1,97 @@
+"""
+Module focused on the Inverse Distance Weighting interpolation technique.
+The IDW algorithm is an average moving interpolation that is usually applied to
+highly variable data. The main idea of this interpolation strategy lies in
+fact that it is not desirable to honour local high/low values but rather to look
+at a moving average of nearby data points and estimate the local trends.
+The node value is calculated by averaging the weighted sum of all the points.
+Data points that lie progressively farther from the node inuence much less the
+computed value than those lying closer to the node.
+
+:Theoretical Insight:
+
+    This implementation is based on the simplest form of inverse distance
+    weighting interpolation, proposed by D. Shepard, A two-dimensional
+    interpolation function for irregularly-spaced data, Proceedings of the 23 rd
+    ACM National Conference.
+
+    The interpolation value :math:`u` of a given point :math:`\\mathrm{x}`
+    from a set of samples :math:`u_k = u(\\mathrm{x}_k)`, with
+    :math:`k = 1,2,\\dotsc,\\mathcal{N}`, is given by:
+
+    .. math::
+        u(\\mathrm{x}) = \\displaystyle\\sum_{k=1}^\\mathcal{N}
+        \\frac{w(\\mathrm{x},\\mathrm{x}_k)}
+        {\\displaystyle\\sum_{j=1}^\\mathcal{N} w(\\mathrm{x},\\mathrm{x}_j)}
+        u_k
+
+    where, in general, :math:`w(\\mathrm{x}, \\mathrm{x}_i)` represents the
+    weighting function:
+
+    .. math::
+        w(\\mathrm{x}, \\mathrm{x}_i) = \\| \\mathrm{x} - \\mathrm{x}_i \\|^{-p}
+
+    being :math:`\\| \\mathrm{x} - \\mathrm{x}_i \\|^{-p} \\ge 0` is the
+    Euclidean distance between :math:`\\mathrm{x}` and data point
+    :math:`\\mathrm{x}_i` and :math:`p` is a power parameter, typically equal to
+    2.
+"""
+
+import numpy as np
+from pygem import IDW as OriginalIDW
+from .cad_deformation import CADDeformation
+
+class IDW(CADDeformation, OriginalIDW):
+    """
+    Class that handles the Free Form Deformation on the mesh points.
+
+    :param FFDParameters ffd_parameters: parameters of the Free Form
+        Deformation.
+    :param numpy.ndarray original_mesh_points: coordinates of the original
+        points of the mesh.
+
+    :param list n_control_points: number of control points in the x, y, and z
+        direction. If not provided it is set to [2, 2, 2].
+
+    :cvar numpy.ndarray box_length: dimension of the FFD bounding box, in the
+        x, y and z direction (local coordinate system).
+    :cvar numpy.ndarray box_origin: the x, y and z coordinates of the origin of
+        the FFD bounding box.
+    :cvar numpy.ndarray rot_angle: rotation angle around x, y and z axis of the
+        FFD bounding box.
+    :cvar numpy.ndarray n_control_points: the number of control points in the
+        x, y, and z direction.
+    :cvar numpy.ndarray array_mu_x: collects the displacements (weights) along
+        x, normalized with the box length x.
+    :cvar numpy.ndarray array_mu_y: collects the displacements (weights) along
+        y, normalized with the box length y.
+    :cvar numpy.ndarray array_mu_z: collects the displacements (weights) along
+        z, normalized with the box length z.
+
+    :Example:
+
+        >>> from pygem.cad import IDW
+        >>> idw = IDW()
+        >>> idw.read_parameters(
+        >>>        'tests/test_datasets/parameters_test_idw_iges.prm')
+        >>> input_cad_file_name = "input.iges"
+        >>> modified_cad_file_name = "output.iges"
+        >>> idw(input_cad_file_name, modified_cad_file_name)
+    """
+    def __init__(self,
+                 original_control_points=None,
+                 deformed_control_points=None,
+                 power=2,
+                 u_knots_to_add=30,
+                 v_knots_to_add=30,
+                 t_knots_to_add=30,
+                 tolerance=1e-4):
+        OriginalIDW.__init__(self,
+                             original_control_points=original_control_points,
+                             deformed_control_points=deformed_control_points,
+                             power=power)
+        CADDeformation.__init__(self,
+                                u_knots_to_add=u_knots_to_add,
+                                v_knots_to_add=v_knots_to_add,
+                                t_knots_to_add=t_knots_to_add,
+                                tolerance=tolerance)
diff --git a/pygem/cad/rbf.py b/pygem/cad/rbf.py
@@ -0,0 +1,120 @@
+"""
+Module focused on the implementation of the Radial Basis Functions interpolation
+technique.  This technique is still based on the use of a set of parameters, the
+so-called control points, as for FFD, but RBF is interpolatory. Another
+important key point of RBF strategy relies in the way we can locate the control
+points: in fact, instead of FFD where control points need to be placed inside a
+regular lattice, with RBF we hano no more limitations. So we have the
+possibility to perform localized control points refiniments.
+The module is analogous to the freeform one.
+
+:Theoretical Insight:
+
+    As reference please consult M.D. Buhmann, Radial Basis Functions, volume 12
+    of Cambridge monographs on applied and computational mathematics. Cambridge
+    University Press, UK, 2003.  This implementation follows D. Forti and G.
+    Rozza, Efficient geometrical parametrization techniques of interfaces for
+    reduced order modelling: application to fluid-structure interaction coupling
+    problems, International Journal of Computational Fluid Dynamics.
+
+    RBF shape parametrization technique is based on the definition of a map,
+    :math:`\\mathcal{M}(\\boldsymbol{x}) : \\mathbb{R}^n \\rightarrow
+    \\mathbb{R}^n`, that allows the possibility of transferring data across
+    non-matching grids and facing the dynamic mesh handling. The map introduced
+    is defines as follows
+
+    .. math::
+        \\mathcal{M}(\\boldsymbol{x}) = p(\\boldsymbol{x}) + 
+        \\sum_{i=1}^{\\mathcal{N}_C} \\gamma_i
+        \\varphi(\\| \\boldsymbol{x} - \\boldsymbol{x_{C_i}} \\|)
+
+    where :math:`p(\\boldsymbol{x})` is a low_degree polynomial term,
+    :math:`\\gamma_i` is the weight, corresponding to the a-priori selected
+    :math:`\\mathcal{N}_C` control points, associated to the :math:`i`-th basis
+    function, and :math:`\\varphi(\\| \\boldsymbol{x} - \\boldsymbol{x_{C_i}}
+    \\|)` a radial function based on the Euclidean distance between the control
+    points position :math:`\\boldsymbol{x_{C_i}}` and :math:`\\boldsymbol{x}`.
+    A radial basis function, generally, is a real-valued function whose value
+    depends only on the distance from the origin, so that
+    :math:`\\varphi(\\boldsymbol{x}) = \\tilde{\\varphi}(\\| \\boldsymbol{x}
+    \\|)`.
+
+    The matrix version of the formula above is:
+
+    .. math::
+        \\mathcal{M}(\\boldsymbol{x}) = \\boldsymbol{c} +
+        \\boldsymbol{Q}\\boldsymbol{x} +
+        \\boldsymbol{W^T}\\boldsymbol{d}(\\boldsymbol{x})
+
+    The idea is that after the computation of the weights and the polynomial
+    terms from the coordinates of the control points before and after the
+    deformation, we can deform all the points of the mesh accordingly.  Among
+    the most common used radial basis functions for modelling 2D and 3D shapes,
+    we consider Gaussian splines, Multi-quadratic biharmonic splines, Inverted
+    multi-quadratic biharmonic splines, Thin-plate splines, Beckert and
+    Wendland :math:`C^2` basis and Polyharmonic splines all defined and
+    implemented below.
+"""
+
+import numpy as np
+from pygem import RBF as OriginalRBF
+from .cad_deformation import CADDeformation
+
+class RBF(CADDeformation, OriginalRBF):
+    """
+    Class that handles the Free Form Deformation on the mesh points.
+
+    :param FFDParameters ffd_parameters: parameters of the Free Form
+        Deformation.
+    :param numpy.ndarray original_mesh_points: coordinates of the original
+        points of the mesh.
+
+    :param list n_control_points: number of control points in the x, y, and z
+        direction. If not provided it is set to [2, 2, 2].
+
+    :cvar numpy.ndarray box_length: dimension of the FFD bounding box, in the
+        x, y and z direction (local coordinate system).
+    :cvar numpy.ndarray box_origin: the x, y and z coordinates of the origin of
+        the FFD bounding box.
+    :cvar numpy.ndarray rot_angle: rotation angle around x, y and z axis of the
+        FFD bounding box.
+    :cvar numpy.ndarray n_control_points: the number of control points in the
+        x, y, and z direction.
+    :cvar numpy.ndarray array_mu_x: collects the displacements (weights) along
+        x, normalized with the box length x.
+    :cvar numpy.ndarray array_mu_y: collects the displacements (weights) along
+        y, normalized with the box length y.
+    :cvar numpy.ndarray array_mu_z: collects the displacements (weights) along
+        z, normalized with the box length z.
+
+    :Example:
+
+        >>> from pygem.cad import RBF
+        >>> rbf = RBF()
+        >>> rbf.read_parameters(
+        >>>        'tests/test_datasets/parameters_test_ffd_iges.prm')
+        >>> input_cad_file_name = "input.iges"
+        >>> modified_cad_file_name = "output.iges"
+        >>> rbf(input_cad_file_name, modified_cad_file_name)
+    """
+    def __init__(self,
+                 original_control_points=None,
+                 deformed_control_points=None,
+                 func='gaussian_spline',
+                 radius=0.5,
+                 extra_parameter=None,
+                 u_knots_to_add=30,
+                 v_knots_to_add=30,
+                 t_knots_to_add=30,
+                 tolerance=1e-4):
+        OriginalRBF.__init__(self, 
+                             original_control_points=original_control_points, 
+                             deformed_control_points=deformed_control_points,
+                             func=func,
+                             radius=radius,
+                             extra_parameter=extra_parameter)
+        CADDeformation.__init__(self,
+                                u_knots_to_add=u_knots_to_add,
+                                v_knots_to_add=v_knots_to_add,
+                                t_knots_to_add=t_knots_to_add,
+                                tolerance=tolerance)
diff --git a/test.py b/test.py
@@ -21,9 +21,7 @@
 
 
 test_cad = [
-    'tests/test_igeshandler.py',
-    'tests/test_nurbshandler.py',
-    'tests/test_stephandler.py',
+    'tests/test_ffdcad.py',
 ]
 
 default_argv = ['--tests'] + test_defaults
diff --git a/tests/test_ffd.py b/tests/test_ffd.py
@@ -382,40 +382,3 @@ def test_ffd_sphere_mod(self):
             'tests/test_datasets/meshpoints_sphere_mod.npy')
         mesh_points_test = ffd(mesh_points)
         np.testing.assert_array_almost_equal(mesh_points_test, mesh_points_ref)
-
-    def test_ffd_iges_pipe_mod_through_files(self):
-        from pygem.cad import FFD
-        ffd = FFD()
-        ffd.read_parameters(
-            filename='tests/test_datasets/parameters_test_ffd_iges.prm')
-        ffd('tests/test_datasets/test_pipe.iges', 'test_pipe_result.iges')
-        with open('test_pipe_result.iges', "r") as created, \
-             open('tests/test_datasets/test_pipe_out_true.iges', "r") as reference:
-             ref = reference.readlines()[5:]
-             cre = created.readlines()[5:]
-             self.assertEqual(len(ref),len(cre))
-             for i in range(len(cre)):
-                 self.assertMultiLineEqual(ref[i], cre[i])
-        self.addCleanup(os.remove, 'test_pipe_result.iges')
-
-    def test_ffd_iges_pipe_mod_through_topods_shape(self):
-        from pygem.cad.igeshandler import IgesHandler
-        from pygem.cad import FFD
-        from OCC.Core.TopoDS import TopoDS_Shape
-        iges_handler = IgesHandler()
-        orig_shape = iges_handler.load_shape_from_file(
-                     filename='tests/test_datasets/test_pipe_hollow.iges')
-        ffd = FFD()
-        ffd.read_parameters(
-            filename='tests/test_datasets/parameters_test_ffd_iges.prm')
-        mod_shape = ffd(orig_shape)
-        iges_handler.write_shape_to_file(mod_shape, 'test_pipe_hollow_result.iges')
-        with open('test_pipe_hollow_result.iges', "r") as created, \
-             open('tests/test_datasets/test_pipe_hollow_out_true.iges', "r") as reference:
-             ref = reference.readlines()[5:]
-             cre = created.readlines()[5:]
-             self.assertEqual(len(ref),len(cre))
-             for i in range(len(cre)):
-                 self.assertMultiLineEqual(ref[i], cre[i])
-        self.addCleanup(os.remove, 'test_pipe_hollow_result.iges')
-
diff --git a/tests/test_ffdcad.py b/tests/test_ffdcad.py
@@ -0,0 +1,42 @@
+import filecmp
+import os
+from unittest import TestCase
+
+import numpy as np
+from OCC.Core.TopoDS import TopoDS_Shape
+
+from pygem.cad import FFD
+from pygem.cad import CADDeformation
+
+class TestFFDCAD(TestCase):
+
+    def test_ffd_iges_pipe_mod_through_files(self):
+        ffd = FFD()
+        ffd.read_parameters(
+            filename='tests/test_datasets/parameters_test_ffd_iges.prm')
+        ffd('tests/test_datasets/test_pipe.iges', 'test_pipe_result.iges')
+        with open('test_pipe_result.iges', "r") as created, \
+             open('tests/test_datasets/test_pipe_out_true.iges', "r") as reference:
+             ref = reference.readlines()[5:]
+             cre = created.readlines()[5:]
+             self.assertEqual(len(ref),len(cre))
+             for i in range(len(cre)):
+                 self.assertMultiLineEqual(ref[i], cre[i])
+        self.addCleanup(os.remove, 'test_pipe_result.iges')
+
+    def test_ffd_iges_pipe_mod_through_topods_shape(self):
+        filename = 'tests/test_datasets/test_pipe_hollow.iges'
+        orig_shape = CADDeformation.read_shape(filename)
+        ffd = FFD()
+        ffd.read_parameters(
+            filename='tests/test_datasets/parameters_test_ffd_iges.prm')
+        mod_shape = ffd(orig_shape)
+        CADDeformation.write_shape('test_pipe_hollow_result.iges', mod_shape)
+        with open('test_pipe_hollow_result.iges', "r") as created, \
+             open('tests/test_datasets/test_pipe_hollow_out_true.iges', "r") as reference:
+             ref = reference.readlines()[5:]
+             cre = created.readlines()[5:]
+             self.assertEqual(len(ref),len(cre))
+             for i in range(len(cre)):
+                 self.assertMultiLineEqual(ref[i], cre[i])
+        self.addCleanup(os.remove, 'test_pipe_hollow_result.iges')

Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,7 @@`
`21`	`21`
`22`	`22`
`23`	`23`	`test_cad = [`
`24`		`- 'tests/test_igeshandler.py',`
`25`		`- 'tests/test_nurbshandler.py',`
`26`		`- 'tests/test_stephandler.py',`
	`24`	`+ 'tests/test_ffdcad.py',`
`27`	`25`	`]`
`28`	`26`
`29`	`27`	`default_argv = ['--tests'] + test_defaults`