OwlCyberSecurity - MANAGER
Edit File: triinterpolate.cpython-38.pyc
U ��]�� � @ s d Z ddlZddlmZ ddlmZ ddlmZ ddl m Z dZ G dd � d e �Z G d d � d e �ZG d d � d e �ZG dd� d�ZG dd� d�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de �Zd.d d �Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Z d*d+� Z d,d-� Z dS )/z( Interpolation inside triangular grids. � N)�cbook)� Triangulation)� TriFinder)� TriAnalyzer)�TriInterpolator�LinearTriInterpolator�CubicTriInterpolatorc @ s4 e Zd ZdZd dd�ZdZdZd dd �Zd d � ZdS )r a� Abstract base class for classes used to perform interpolation on triangular grids. Derived classes implement the following methods: - ``__call__(x, y)`` , where x, y are array_like point coordinates of the same shape, and that returns a masked array of the same shape containing the interpolated z-values. - ``gradient(x, y)`` , where x, y are array_like point coordinates of the same shape, and that returns a list of 2 masked arrays of the same shape containing the 2 derivatives of the interpolator (derivatives of interpolated z values with respect to x and y). Nc C s~ t |t�std��|| _t�|�| _| jj| jjjkr>td��|d k rXt |t �sXtd��|pd| j� � | _ d| _ d| _ d | _d S )Nz Expected a Triangulation objectz=z array must have same length as triangulation x and y arrayszExpected a TriFinder object� �?)� isinstancer � ValueError�_triangulation�np�asarray�_z�shape�xr Z get_trifinder� _trifinder�_unit_x�_unit_y� _tri_renum��self� triangulation�z� trifinder� r �?/usr/lib/python3/dist-packages/matplotlib/tri/triinterpolate.py�__init__" s zTriInterpolator.__init__a� Returns a masked array containing interpolated values at the specified x,y points. Parameters ---------- x, y : array-like x and y coordinates of the same shape and any number of dimensions. Returns ------- z : np.ma.array Masked array of the same shape as *x* and *y*; values corresponding to (*x*, *y*) points outside of the triangulation are masked out. a� Returns a list of 2 masked arrays containing interpolated derivatives at the specified x,y points. Parameters ---------- x, y : array-like x and y coordinates of the same shape and any number of dimensions. Returns ------- dzdx, dzdy : np.ma.array 2 masked arrays of the same shape as *x* and *y*; values corresponding to (x,y) points outside of the triangulation are masked out. The first returned array contains the values of :math:`\frac{\partial z}{\partial x}` and the second those of :math:`\frac{\partial z}{\partial y}`. �r c C s� t j|t jd�}t j|t jd�}|j}|j|jkrFtd�|j|j���t �|�}t �|�}|| j }|| j }t � |�}|dkr�| � ||�}n&|j|kr�td�|j|���t �|�}|dk} | j dkr�|| } n| j || } || } || } g } |D ]�}zdddd �| }W n t k �r, td ��Y nX d d | j d | j g| }t j |t jd�}t j|| < | �|| | | �| || < | t jj|�|�d d �g7 } q�| S )a Versatile (private) method defined for all TriInterpolators. :meth:`_interpolate_multikeys` is a wrapper around method :meth:`_interpolate_single_key` (to be defined in the child subclasses). :meth:`_interpolate_single_key actually performs the interpolation, but only for 1-dimensional inputs and at valid locations (inside unmasked triangles of the triangulation). The purpose of :meth:`_interpolate_multikeys` is to implement the following common tasks needed in all subclasses implementations: - calculation of containing triangles - dealing with more than one interpolation request at the same location (e.g., if the 2 derivatives are requested, it is unnecessary to compute the containing triangles twice) - scaling according to self._unit_x, self._unit_y - dealing with points outside of the grid (with fill value np.nan) - dealing with multi-dimensional *x*, *y* arrays: flattening for :meth:`_interpolate_params` call and final reshaping. (Note that np.vectorize could do most of those things very well for you, but it does it by function evaluations over successive tuples of the input arrays. Therefore, this tends to be more time consuming than using optimized numpy functions - e.g., np.dot - which can be used easily on the flattened inputs, in the child-subclass methods :meth:`_interpolate_single_key`.) It is guaranteed that the calls to :meth:`_interpolate_single_key` will be done with flattened (1-d) array_like input parameters `x`, `y` and with flattened, valid `tri_index` arrays (no -1 index allowed). Parameters ---------- x, y : array_like x and y coordinates indicating where interpolated values are requested. tri_index : integer array_like, optional Array of the containing triangle indices, same shape as *x* and *y*. Defaults to None. If None, these indices will be computed by a TriFinder instance. (Note: For point outside the grid, tri_index[ipt] shall be -1). return_keys : tuple of keys from {'z', 'dzdx', 'dzdy'} Defines the interpolation arrays to return, and in which order. Returns ------- ret : list of arrays Each array-like contains the expected interpolated values in the order defined by *return_keys* parameter. ��dtypez2x and y shall have same shapes. Given: {0} and {1}NzTtri_index array is provided and shall have same shape as x and y. Given: {0} and {1}���r � � )r �dzdx�dzdyz<return_keys items shall take values in {'z', 'dzdx', 'dzdy'}r F)�copy)r r �float64r r �format�ravelr r �sizer r �KeyError�empty�nan�_interpolate_single_keyZmaZmasked_invalid�reshape)r r �y� tri_index� return_keysZsh_retZx_scaledZy_scaledZsize_retZmask_inZvalid_tri_indexZvalid_xZvalid_y�ret� return_key� return_indexZscaleZret_locr r r �_interpolate_multikeysi s` 8 � �� �� z&TriInterpolator._interpolate_multikeysc C s t d��dS )a` Performs the interpolation at points belonging to the triangulation (inside an unmasked triangles). Parameters ---------- return_index : string key from {'z', 'dzdx', 'dzdy'} Identifies the requested values (z or its derivatives) tri_index : 1d integer array Valid triangle index (-1 prohibited) x, y : 1d arrays, same shape as `tri_index` Valid locations where interpolation is requested. Returns ------- ret : 1-d array Returned array of the same size as *tri_index* zCTriInterpolator subclassesshould implement _interpolate_single_key!N��NotImplementedError�r r4 r1 r r0 r r r r. � s z'TriInterpolator._interpolate_single_key)N)Nr ) �__name__� __module__� __qualname__�__doc__r �_docstring__call__�_docstringgradientr6 r. r r r r r s � lr c @ sB e Zd ZdZd dd�Zdd� Zeje_dd� Zej e_d d � Z dS ) r a A LinearTriInterpolator performs linear interpolation on a triangular grid. Each triangle is represented by a plane so that an interpolated value at point (x,y) lies on the plane of the triangle containing (x,y). Interpolated values are therefore continuous across the triangulation, but their first derivatives are discontinuous at edges between triangles. Parameters ---------- triangulation : :class:`~matplotlib.tri.Triangulation` object The triangulation to interpolate over. z : array_like of shape (npoints,) Array of values, defined at grid points, to interpolate between. trifinder : :class:`~matplotlib.tri.TriFinder` object, optional If this is not specified, the Triangulation's default TriFinder will be used by calling :func:`matplotlib.tri.Triangulation.get_trifinder`. Methods ------- `__call__` (x, y) : Returns interpolated values at x,y points `gradient` (x, y) : Returns interpolated derivatives at x,y points Nc C s$ t �| |||� | j�| j�| _d S �N)r r r Z calculate_plane_coefficientsr �_plane_coefficientsr r r r r s �z LinearTriInterpolator.__init__c C s | j ||d dd�d S �Nr �r1 r2 r �r6 �r r r0 r r r �__call__ s ��z LinearTriInterpolator.__call__c C s | j ||d dd�S �N�r$ r% rC rD rE r r r �gradient s �z LinearTriInterpolator.gradientc C sv |dkr:| j |df | | j |df | | j |df S |dkrP| j |df S |dkrf| j |df S td| ��d S )Nr r r" r# r$ r% �Invalid return_key: )rA r r9 r r r r. s � �z-LinearTriInterpolator._interpolate_single_key)N) r: r; r< r= r rF r r> rI r? r. r r r r r � s r c @ sp e Zd ZdZddd�Zdd� Zeje_dd � Zej e_d d � Z dd d �Z e dd� �Z e dd� �Ze dd� �ZdS )r a A CubicTriInterpolator performs cubic interpolation on triangular grids. In one-dimension - on a segment - a cubic interpolating function is defined by the values of the function and its derivative at both ends. This is almost the same in 2-d inside a triangle, except that the values of the function and its 2 derivatives have to be defined at each triangle node. The CubicTriInterpolator takes the value of the function at each node - provided by the user - and internally computes the value of the derivatives, resulting in a smooth interpolation. (As a special feature, the user can also impose the value of the derivatives at each node, but this is not supposed to be the common usage.) Parameters ---------- triangulation : :class:`~matplotlib.tri.Triangulation` object The triangulation to interpolate over. z : array_like of shape (npoints,) Array of values, defined at grid points, to interpolate between. kind : {'min_E', 'geom', 'user'}, optional Choice of the smoothing algorithm, in order to compute the interpolant derivatives (defaults to 'min_E'): - if 'min_E': (default) The derivatives at each node is computed to minimize a bending energy. - if 'geom': The derivatives at each node is computed as a weighted average of relevant triangle normals. To be used for speed optimization (large grids). - if 'user': The user provides the argument `dz`, no computation is hence needed. trifinder : :class:`~matplotlib.tri.TriFinder` object, optional If not specified, the Triangulation's default TriFinder will be used by calling :func:`matplotlib.tri.Triangulation.get_trifinder`. dz : tuple of array_likes (dzdx, dzdy), optional Used only if *kind* ='user'. In this case *dz* must be provided as (dzdx, dzdy) where dzdx, dzdy are arrays of the same shape as *z* and are the interpolant first derivatives at the *triangulation* points. Methods ------- `__call__` (x, y) : Returns interpolated values at x,y points `gradient` (x, y) : Returns interpolated derivatives at x,y points Notes ----- This note is a bit technical and details the way a :class:`~matplotlib.tri.CubicTriInterpolator` computes a cubic interpolation. The interpolation is based on a Clough-Tocher subdivision scheme of the *triangulation* mesh (to make it clearer, each triangle of the grid will be divided in 3 child-triangles, and on each child triangle the interpolated function is a cubic polynomial of the 2 coordinates). This technique originates from FEM (Finite Element Method) analysis; the element used is a reduced Hsieh-Clough-Tocher (HCT) element. Its shape functions are described in [1]_. The assembled function is guaranteed to be C1-smooth, i.e. it is continuous and its first derivatives are also continuous (this is easy to show inside the triangles but is also true when crossing the edges). In the default case (*kind* ='min_E'), the interpolant minimizes a curvature energy on the functional space generated by the HCT element shape functions - with imposed values but arbitrary derivatives at each node. The minimized functional is the integral of the so-called total curvature (implementation based on an algorithm from [2]_ - PCG sparse solver): .. math:: E(z) = \frac{1}{2} \int_{\Omega} \left( \left( \frac{\partial^2{z}}{\partial{x}^2} \right)^2 + \left( \frac{\partial^2{z}}{\partial{y}^2} \right)^2 + 2\left( \frac{\partial^2{z}}{\partial{y}\partial{x}} \right)^2 \right) dx\,dy If the case *kind* ='geom' is chosen by the user, a simple geometric approximation is used (weighted average of the triangle normal vectors), which could improve speed on very large grids. References ---------- .. [1] Michel Bernadou, Kamal Hassan, "Basis functions for general Hsieh-Clough-Tocher triangles, complete or reduced.", International Journal for Numerical Methods in Engineering, 17(5):784 - 789. 2.01. .. [2] C.T. Kelley, "Iterative Methods for Optimization". �min_ENc C s� t �| |||� | j�� t| j�}|�dd�\}}} } } || _| | _| dk} | j| j| | < | j| | _t � |�| _ t � | �| _ t � || j | | j g�| _| j| j | _| �| j�| _| j||d�| _t� | _d S )NTr! ��dz)r r r Zget_cpp_triangulationr Z _get_compressed_triangulation� _trianglesr r r Zptpr r Z column_stack�_pts� _tris_pts�_compute_tri_eccentricities�_eccs� _compute_dof�_dof�_ReducedHCT_Element�_ReferenceElement) r r r �kindr rM Z tri_analyzerZcompressed_trianglesZ compressed_xZ compressed_yZ tri_renumZ node_renumZ node_maskr r r r � s( � �z CubicTriInterpolator.__init__c C s | j ||d dd�d S rB rD rE r r r rF � s ��z CubicTriInterpolator.__call__c C s | j ||d dd�S rG rD rE r r r rI � s �z CubicTriInterpolator.gradientc C s� | j | }| �|||�}| j| }tj| j| dd�}|dkrN| j�|||�S |dkr�| �|�} | j� || ||�} |dkr�| d d �ddf S | d d �ddf S n t d| ��d S )Nr" ��axisr rH r$ r rJ ) rP �_get_alpha_vecrR r � expand_dimsrT rV �get_function_values� _get_jacobian�get_function_derivativesr ) r r4 r1 r r0 �tris_pts�alpha�ecc�dof�Jr$ r r r r. � s, � �z,CubicTriInterpolator._interpolate_single_keyc C s` |dkr&|dkrt d��t| |d�}n2|dkr8t| �}n |dkrJt| �}nt d�|���|�� S )ar Computes and returns nodal dofs according to kind Parameters ---------- kind : {'min_E', 'geom', 'user'} Choice of the _DOF_estimator subclass to perform the gradient estimation. dz : tuple of array_likes (dzdx, dzdy), optional Used only if *kind*=user; in this case passed to the :class:`_DOF_estimator_user`. Returns ------- dof : array_like, shape (npts,2) Estimation of the gradient at triangulation nodes (stored as degree of freedoms of reduced-HCT triangle elements). �userNzQFor a CubicTriInterpolator with *kind*='user', a valid *dz* argument is expected.rL ZgeomrK zTCubicTriInterpolator *kind* proposed: {0}; should be one of: 'user', 'geom', 'min_E')r �_DOF_estimator_user�_DOF_estimator_geom�_DOF_estimator_min_Er( �compute_dof_from_df)r rW rM ZTEr r r rS � s �z!CubicTriInterpolator._compute_dofc C s. |j d }|dd�ddd�f |dd�ddd�f }|dd�ddd�f |dd�ddd�f }tj||gdd�}t|�}tj| |gdd�|dd�ddd�f }t||�} t| �} t|tt�||���} t| | �} td| dd�ddf | dd�ddf g| dd�ddf g| dd�ddf gg�} | S )aT Fast (vectorized) function to compute barycentric coordinates alpha. Parameters ---------- x, y : array-like of dim 1 (shape (nx,)) Coordinates of the points whose points barycentric coordinates are requested tris_pts : array like of dim 3 (shape: (nx,3,2)) Coordinates of the containing triangles apexes. Returns ------- alpha : array of dim 2 (shape (nx,3)) Barycentric coordinates of the points inside the containing triangles. r# Nr" r r! rX )�ndimr �stack�_transpose_vectorized�_prod_vectorized�_pseudo_inv22sym_vectorizedr[ �_to_matrix_vectorized)r r0 r_ ri �a�bZabTZabZOMZmetricZ metric_invZCovar�ksir` r r r rZ � s$ ,,( � ( �z#CubicTriInterpolator._get_alpha_vecc C s� t �| dd�ddd�f | dd�ddd�f �}t �| dd�ddd�f | dd�ddd�f �}t|dd�df |dd�df g|dd�df |dd�df gg�}|S )a Fast (vectorized) function to compute triangle jacobian matrix. Parameters ---------- tris_pts : array like of dim 3 (shape: (nx,3,2)) Coordinates of the containing triangles apexes. Returns ------- J : array of dim 3 (shape (nx,2,2)) Barycentric coordinates of the points inside the containing triangles. J[itri,:,:] is the jacobian matrix at apex 0 of the triangle itri, so that the following (matrix) relationship holds: [dz/dksi] = [J] x [dz/dx] with x: global coordinates ksi: element parametric coordinates in triangle first apex local basis. Nr" r r# )r �arrayrn )r_ ro rp rc r r r r] s 22 �z"CubicTriInterpolator._get_jacobianc C s" t j| dd�ddd�f | dd�ddd�f dd�}t j| dd�ddd�f | dd�ddd�f dd�}t j| dd�ddd�f | dd�ddd�f dd�}tt|�|�dd�ddf }tt|�|�dd�ddf }tt|�|�dd�ddf }t|| | g|| | g|| | gg�S )a� Computes triangle eccentricities Parameters ---------- tris_pts : array like of dim 3 (shape: (nx,3,2)) Coordinates of the triangles apexes. Returns ------- ecc : array like of dim 2 (shape: (nx,3)) The so-called eccentricity parameters [1] needed for HCT triangular element. Nr# r" rX r )r r[ rl rk rn )r_ ro rp �cZdot_aZdot_bZdot_cr r r rQ 0 s 666 �z0CubicTriInterpolator._compute_tri_eccentricities)rK NN)N)r: r; r< r= r rF r r> rI r? r. rS � staticmethodrZ r] rQ r r r r r $ s ^ � ) # ' r c @ s� e Zd ZdZe�ddddddddddg ddddddddddg ddddddddddg dddddd d ddd g ddddd dddddg d ddd ddddddg dddddddd d d g d dddd dddddg dddd ddddddg g �Ze�ddddddddddg ddddddddddg ddddddddddg d ddd d dddddg d dddddddddg ddddddddddg dddddddddd g ddddddddddg dddddddddd g g �Ze�d ddd ddddddg ddddddddddg ddddddddddg ddddddddddg ddddddddddg ddddddddddg ddddddddddg d dddddddddg ddddddddddg g �Ze�ddddddddddg d dddddddddg ddddddddddg d dddd dddddg ddddddddddg ddddddddddg ddddddddddg ddddddddddg ddddddddddg g �Z e�ddgddgddgd d gd d gddgg�Z e�dddgdddgdddgdddgdddgddd gdddgdddgddd gg �Z dZ ejdddgdddgdddgdddgdddgdddgdddgdddgdddgg ej d�Zejdgej d�d Ze�dddgdddgdddgg�Ze�d dgd dgg�Ze�dd gdd gg�Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd*d%d&�Zd'd(� Zd)S )+rU aN Implementation of reduced HCT triangular element with explicit shape functions. Computes z, dz, d2z and the element stiffness matrix for bending energy: E(f) = integral( (d2z/dx2 + d2z/dy2)**2 dA) *** Reference for the shape functions: *** [1] Basis functions for general Hsieh-Clough-Tocher _triangles, complete or reduced. Michel Bernadou, Kamal Hassan International Journal for Numerical Methods in Engineering. 17(5):784 - 789. 2.01 *** Element description: *** 9 dofs: z and dz given at 3 apex C1 (conform) � g @g п� �?g �?r g ��� @g �?g �g �g �?� �g �?g �� �� g�q �q �?g �q �q�?g �q �q�?g9��8���?r g "@� @c C s� t j|dd�dd�df }t|| dd�}t|| dd�}|dd�ddf }|dd�ddf }|dd�ddf } || } || } | | } t| | g| | g| | g| | g| | g| | g| | g| | g| | g|| | gg �} t| j| �}|t|dd�ddf t| j| ��7 }|t|dd�ddf t| j| ��7 }|t|dd�ddf t| j | ��7 }t|d| dd�}t||�dd�ddf S )a� Parameters ---------- alpha : is a (N x 3 x 1) array (array of column-matrices) of barycentric coordinates, ecc : is a (N x 3 x 1) array (array of column-matrices) of triangle eccentricities, dofs : is a (N x 1 x 9) arrays (arrays of row-matrices) of computed degrees of freedom. Returns ------- Returns the N-array of interpolated function values. r" rX Nr r# � ) r �argmin�_roll_vectorizedrn rl �M�_scalar_vectorized�M0�M1�M2)r r` ra �dofs�subtrirq �Er r0 r �x_sq�y_sq�z_sq�V�prod�sr r r r\ � sB � � � �z'_ReducedHCT_Element.get_function_valuesc C s t j|dd�dd�df }t|| dd�}t|| dd�}|dd�ddf }|dd�ddf } |dd�ddf } || } | | } | | } td| d| gd| dgdd| gd | | d | | | gd | | | d | | gd | | | | gd | | | g| d | | g| d | | | g|| | | || | | gg �}t|t| j|ddd ��}t| j|�}|t|dd�ddf t| j |��7 }|t|dd�ddf t| j |��7 }|t|dd�ddf t| j |��7 }t|d | dd�}t||�}t |�}t|t |��}|S ) a� Parameters ---------- *alpha* is a (N x 3 x 1) array (array of column-matrices of barycentric coordinates) *J* is a (N x 2 x 2) array of jacobian matrices (jacobian matrix at triangle first apex) *ecc* is a (N x 3 x 1) array (array of column-matrices of triangle eccentricities) *dofs* is a (N x 1 x 9) arrays (arrays of row-matrices) of computed degrees of freedom. Returns ------- Returns the values of interpolated function derivatives [dz/dx, dz/dy] in global coordinates at locations alpha, as a column-matrices of shape (N x 2 x 1). r" rX Nr r# rx rw ru ry r{ �� block_sizerY r| )r r} r~ rn rl �_extract_submatrices� rotate_dVr r� r� r� r� �_safe_inv22_vectorizedrk )r r` rc ra r� r� rq r� r r0 r r� r� r� ZdVr� Zdsdksi�dfdksi�J_invZdfdxr r r r^ � sT � � � � � z,_ReducedHCT_Element.get_function_derivativesc C s2 | � ||�}t||�}| �|�}t||�}t|�S )a� Parameters ---------- *alpha* is a (N x 3 x 1) array (array of column-matrices) of barycentric coordinates *J* is a (N x 2 x 2) array of jacobian matrices (jacobian matrix at triangle first apex) *ecc* is a (N x 3 x 1) array (array of column-matrices) of triangle eccentricities *dofs* is a (N x 1 x 9) arrays (arrays of row-matrices) of computed degrees of freedom. Returns ------- Returns the values of interpolated function 2nd-derivatives [d2z/dx2, d2z/dy2, d2z/dxdy] in global coordinates at locations alpha, as a column-matrices of shape (N x 3 x 1). )�get_d2Sidksij2rl �get_Hrot_from_Jrk ) r r` rc ra r� �d2sdksi2Zd2fdksi2�H_rotZd2fdx2r r r �get_function_hessians s z)_ReducedHCT_Element.get_function_hessiansc C s� t j|dd�dd�df }t|| dd�}t|| dd�}|dd�ddf }|dd�ddf }|dd�ddf }td| d| d| gd| ddgdd| dgd| d| d | d| d| gd| d | d| d| d| gd| d | dd | gd| dd| gdd| d| gdd| d | d | gd | d | || | gg �} t| t| j|d dd ��} t| j| �} | t|dd�ddf t| j | ��7 } | t|dd�ddf t| j | ��7 } | t|dd�ddf t| j | ��7 } t| d | dd�} | S ) a� Parameters ---------- *alpha* is a (N x 3 x 1) array (array of column-matrices) of barycentric coordinates *ecc* is a (N x 3 x 1) array (array of column-matrices) of triangle eccentricities Returns ------- Returns the arrays d2sdksi2 (N x 3 x 1) Hessian of shape functions expressed in covariant coordinates in first apex basis. r" rX Nr r# g @ru r{ g @ry r| r� ) r r} r~ rn rl r� � rotate_d2Vr r� r� r� r� ) r r` ra r� rq r� r r0 r Zd2Vr� r� r r r r� * sH $$� � � � �z"_ReducedHCT_Element.get_d2Sidksij2c C s� t �|d�}t| j|�}t| j|�}t j|ddgt jd�}d|dd�ddf< d|dd�ddf< d|dd�ddf< ||dd�dd�dd�f< ||dd�dd�dd�f< ||dd�d d�d d�f< | j|d d �\}}t j|ddgt jd�} | j} | j } t | j �D ]l} t � | | dd�f |�� |d�} t �| d �} | | }| �| |�}t||�}| |tt|| j�t|�� 7 } q�ttt|�| �|�} t|| �S ) a Parameters ---------- *J* is a (N x 2 x 2) array of jacobian matrices (jacobian matrix at triangle first apex) *ecc* is a (N x 3 x 1) array (array of column-matrices) of triangle eccentricities Returns ------- Returns the element K matrices for bending energy expressed in GLOBAL nodal coordinates. K_ij = integral [ (d2zi/dx2 + d2zi/dy2) * (d2zj/dx2 + d2zj/dy2) dA] tri_J is needed to rotate dofs from local basis to global basis r rz r r" Nr| � � � T)� return_arear# )r r* rl �J0_to_J1�J0_to_J2�zerosr' r� �gauss_w� gauss_pts�range�n_gaussZtiler/ r[ r� r� rk r� )r rc ra �n�J1�J2ZDOF_rotr� �area�K�weightsZptsZigaussr` ZweightZ d2Skdksi2Zd2Skdx2r r r �get_bending_matricesV s: � ��z(_ReducedHCT_Element.get_bending_matricesFc C s t |�}|dd�ddf }|dd�ddf }|dd�ddf }|dd�ddf }t|| || || g|| || || gd| | d| | || || gg�}|s�|S d|dd�ddf |dd�ddf |dd�ddf |dd�ddf } || fS dS )as Parameters ---------- *J* is a (N x 2 x 2) array of jacobian matrices (jacobian matrix at triangle first apex) Returns ------- Returns H_rot used to rotate Hessian from local basis of first apex, to global coordinates. if *return_area* is True, returns also the triangle area (0.5*det(J)) Nr r" r# rv )r� rn ) r rc r� r� ZJi00ZJi11ZJi10ZJi01r� r� r r r r� � s $�Lz#_ReducedHCT_Element.get_Hrot_from_Jc C s� t �|d�}t j|t jd�}t j|dt jd�}dddddd g}dd d g} t||d d �df d |d d �df d d ||d d �df d |d d �df d d ||d d �df d |d d �df d d g g�} t j|d dgt jd�} tt| �t| ��} t| | �} | � ||�}t � |t � |||� �}t � | t � |||� �}t � | t � |||� �}|t � ||| � }t j |dd�}t||�d d �d d �df }| t � |dg|� d d �dd d �f }t j t � |�t � |�d�}||||fS )aG Builds K and F for the following elliptic formulation: minimization of curvature energy with value of function at node imposed and derivatives 'free'. Builds the global Kff matrix in cco format. Builds the full Ff vec Ff = - Kfc x Uc Parameters ---------- *J* is a (N x 2 x 2) array of jacobian matrices (jacobian matrix at triangle first apex) *ecc* is a (N x 3 x 1) array (array of column-matrices) of triangle eccentricities *triangles* is a (N x 3) array of nodes indexes. *Uc* is (N x 3) array of imposed displacements at nodes Returns ------- (Kff_rows, Kff_cols, Kff_vals) Kff matrix in coo format - Duplicate (row, col) entries must be summed. Ff: force vector - dim npts * 3 r r r! r" r# r� � r� � r| r� Nrz rX �r� )r r* �arange�int32Zfullrn �onesrl rk r� r) Zix_r[ �bincount)r rc ra � triangles�UcZntriZ vec_rangeZ c_indicesZf_dofZc_dofZ f_dof_indicesZexpand_indicesZ f_row_indicesZ f_col_indicesZK_elem�Kff_vals�Kff_rows�Kff_colsZKfc_elemZUc_elemZFf_elemZ Ff_indices�Ffr r r �get_Kff_and_Ff� s> �� &z"_ReducedHCT_Element.get_Kff_and_FfN)F)r: r; r< r= r rr r r� r� r� r� r� r� r' r� r� r� r� r� r� r\ r^ r� r� r� r� r� r r r r rU Q s� � � � � � � �� "%;,5 rU c @ s4 e Zd ZdZdd� Zdd� Zdd� Zedd � �Zd S ) �_DOF_estimatoraj Abstract base class for classes used to perform estimation of a function first derivatives, and deduce the dofs for a CubicTriInterpolator using a reduced HCT element formulation. Derived classes implement compute_df(self,**kwargs), returning np.vstack([dfx,dfy]).T where : dfx, dfy are the estimation of the 2 gradient coordinates. c K s^ t |t�std��|j| _|j| _|j| _|j| _|j|j | _| _ | j f |�| _ | � � d S )Nz&Expected a CubicTriInterpolator object) r r r rO rP r r rN r r � compute_dzrM rh )r Z interpolator�kwargsr r r r � s � z_DOF_estimator.__init__c K s t �d S r@ r7 )r r� r r r r� s z_DOF_estimator.compute_dzc C s6 t �| j�}| j| j }| j| j }| �|||�}|S )za Computes reduced-HCT elements degrees of freedom, knowing the gradient. )r r] rP r rN rM � get_dof_vec)r rc �tri_z�tri_dzZtri_dofr r r rh s z"_DOF_estimator.compute_dof_from_dfc C sr | j d }tj|dgtjd�}ttj|�}ttj|�}t|tj|dd�ddd�f dd��}t|tj|dd�ddd�f dd��}t|tj|dd�ddd�f dd��} t |dd�ddf |dd�ddf | dd�ddf g|dd�ddf |dd�ddf | dd�ddf gg�} | |dd�ddd �f< | dd�df |dd�dd d �f< | dd�df |dd�ddd �f< |S ) a� Computes the dof vector of a triangle, knowing the value of f, df and of the local Jacobian at each node. *tri_z*: array of shape (3,) of f nodal values *tri_dz*: array of shape (3,2) of df/dx, df/dy nodal values *J*: Jacobian matrix in local basis of apex 0 Returns dof array of shape (9,) so that for each apex iapex: dof[iapex*3+0] = f(Ai) dof[iapex*3+1] = df(Ai).(AiAi+) dof[iapex*3+2] = df(Ai).(AiAi-)] r rz r Nr# rX r" r� r| r� ) r r r� r' rl rU r� r� r[ rn ) r� r� rc Znptrb r� r� Zcol0Zcol1Zcol2r� r r r r� s &&&22�""z_DOF_estimator.get_dof_vecN) r: r; r< r= r r� rh rt r� r r r r r� � s r� c @ s e Zd ZdZdd� ZdS )re z3dz is imposed by user; accounts for scaling if any.c C s, |\}}|| j }|| j }t�||g�jS r@ )r r r �vstack�T)r rM r$ r% r r r r� : s z _DOF_estimator_user.compute_dzN)r: r; r< r= r� r r r r re 7 s re c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) rf z=Fast 'geometric' approximation, recommended for large arrays.c C s� | � � }| �� }tjt�| j�t�|�d�}t�|�}t�|�}td�D ]\}|dd�|f |dd�df |dd�|f< |dd�|f |dd�df |dd�|f< qHtjt�| j�t�|�d�}tjt�| j�t�|�d�}|| } || } t�| | g�j S )a� self.df is computed as weighted average of _triangles sharing a common node. On each triangle itri f is first assumed linear (= ~f), which allows to compute d~f[itri] Then the following approximation of df nodal values is then proposed: f[ipt] = SUM ( w[itri] x d~f[itri] , for itri sharing apex ipt) The weighted coeff. w[itri] are proportional to the angle of the triangle itri at apex ipt r� r| Nr r" ) �compute_geom_weights�compute_geom_gradsr r� r) rN � empty_liker� r� r� ) r Z el_geom_wZ el_geom_gradZ w_node_sumZdfx_el_wZdfy_el_wZiapexZ dfx_node_sumZ dfy_node_sumZ dfx_estimZ dfy_estimr r r r� D s& � ,.��z _DOF_estimator_geom.compute_dzc C sF t �t �| jd�dg�}| j}td�D �]}|dd�|d dd�f }|dd�|d d dd�f }|dd�|d d dd�f }t �|dd�df |dd�df |dd�df |dd�df �}t �|dd�df |dd�df |dd�df |dd�df �}t �|| t j d �} dt �| d � |dd�|f< q&|S )z� Builds the (nelems x 3) weights coeffs of _triangles angles, renormalized so that np.sum(weights, axis=1) == np.ones(nelems) r r| Nr" rv ) r r� r* rN rP r� Zarctan2�absZpi) r r� r_ ZiptZp0Zp1Zp2Zalpha1Zalpha2Zangler r r r� e s DD z(_DOF_estimator_geom.compute_geom_weightsc C s~ | j }| j| j }|dd�ddd�f |dd�ddd�f }|dd�ddd�f |dd�ddd�f }t�||g�}t|�}|dd�df |dd�df }|dd�df |dd�df }t�||g�j} t�| �} | dd�df |dd�ddf | dd�df |dd�ddf | dd�df< | dd�df |dd�ddf | dd�df |dd�ddf | dd�df< | S )z� Compute the (global) gradient component of f assumed linear (~f). returns array df of shape (nelems,2) df[ielem].dM[ielem] = dz[ielem] i.e. df = dz x dM = dM.T^-1 x dz Nr" r r# ) rP r rN r Zdstackr� r� r� r� ) r r_ Ztris_fZdM1ZdM2ZdMZdM_invZdZ1ZdZ2ZdZZdfr r r r� { s ,, PPz&_DOF_estimator_geom.compute_geom_gradsN)r: r; r< r= r� r� r� r r r r rf A s !rf c @ s e Zd ZdZdd� Zdd� ZdS )rg z� The 'smoothest' approximation, df is computed through global minimization of the bending energy: E(f) = integral[(d2z/dx2 + d2z/dy2 + 2 d2z/dxdy)**2 dA] c C s |j | _ t�| |� d S r@ )rR rf r )r Z Interpolatorr r r r � s z _DOF_estimator_min_E.__init__c C s t �| �}t�|�}t� }t�| j�}| j}| j }| j | j }|� ||||�\}} } } d} | j d } t | || | | fd�}|�� t|| || d�\}}tj�|�|�| �}||k r�t�d� |}tj| jj d dgtjd�}|ddd� |dd�df< |d dd� |dd�d f< |S ) z{ Elliptic solver for bending energy minimization. Uses a dedicated 'toy' sparse Jacobi PCG solver. 绽���|�=r )r )�Arp �x0�tolz�In TriCubicInterpolator initialization, PCG sparse solver did not converge after 1000 iterations. `geom` approximation is used instead of `min_E`r# r Nr" )rf r� r r) rU r r] rP rR rN r r� r �_Sparse_Matrix_coo� compress_csc�_cg�linalg�norm�dotr Z_warn_externalr, rO r' )r Zdz_initZUf0Zreference_elementrc Zeccsr� r� r� r� r� r� r� Zn_dofZKff_cooZUf�errZerr0rM r r r r� � s8 � � z _DOF_estimator_min_E.compute_dzN)r: r; r< r= r r� r r r r rg � s rg c @ sH e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Ze d d� �Z dS )r� c C sF |\| _ | _tj|tjd�| _tj|tjd�| _tj|tjd�| _dS )a4 Creates a sparse matrix in coo format *vals*: arrays of values of non-null entries of the matrix *rows*: int arrays of rows of non-null entries of the matrix *cols*: int arrays of cols of non-null entries of the matrix *shape*: 2-tuple (n,m) of matrix shape r N) r� �mr r r' �valsr� �rows�cols)r r� r� r� r r r r r � s z_Sparse_Matrix_coo.__init__c C s2 |j | jfkst�tj| j| j|| j | jd�S )z� Dot product of self by a vector *V* in sparse-dense to dense format *V* dense vector of shape (self.m,) )r� Z minlength)r r� �AssertionErrorr r� r� r� r� )r r� r r r r� � s �z_Sparse_Matrix_coo.dotc C sR t j| j| j| j ddd�\}}}| j| | _| j| | _t j|| jd�| _dS )zV Compress rows, cols, vals / summing duplicates. Sort for csc format. T�r5 Zreturn_inverser� N)r �uniquer� r� r� r� r� �r �_r� �indicesr r r r� � s � z _Sparse_Matrix_coo.compress_cscc C sR t j| j| j | j ddd�\}}}| j| | _| j| | _t j|| jd�| _dS )zV Compress rows, cols, vals / summing duplicates. Sort for csr format. Tr� r� N)r r� r� r� r� r� r� r� r r r � compress_csr� s � z _Sparse_Matrix_coo.compress_csrc C sX t j| j| jgt jd�}| jj}t|�D ]*}|| j| | j | f | j| 7 < q(|S )zb Returns a dense matrix representing self. Mainly for debugging purposes. r ) r r� r� r� r' r� r* r� r� r� )r r3 Znvals�ir r r �to_dense s (z_Sparse_Matrix_coo.to_densec C s | � � �� S r@ )r� �__str__)r r r r r� s z_Sparse_Matrix_coo.__str__c C s> | j | jk}tjt| j| j�tjd�}| j| || j | < |S )zF Returns the (dense) vector of the diagonal elements. r )r� r� r r� �minr� r' r� )r Zin_diag�diagr r r r� s z_Sparse_Matrix_coo.diagN) r: r; r< r r� r� r� r� r� �propertyr� r r r r r� � s r� r� �� c C s4 |j }| j|kst�| j|ks"t�tj�|�}| j}t�|d�}|dkrTt� |�}n|}|| � |� } | | } t� |�} d} t� | | �} d}t� t | ��|| k�r||k �r| | | } | � | �}| t� | |� }| || } | | } | }t� | | �} ||| }| | } |d7 }q�tj�| � |�| �}||fS )ak Use Preconditioned Conjugate Gradient iteration to solve A x = b A simple Jacobi (diagonal) preconditionner is used. Parameters ---------- A : _Sparse_Matrix_coo *A* must have been compressed before by compress_csc or compress_csr method. b : array Right hand side of the linear system. Returns ------- x : array The converged solution. err : float The absolute error np.linalg.norm(A.dot(x) - b) Other parameters ---------------- x0 : array Starting guess for the solution. tol : float Tolerance to achieve. The algorithm terminates when the relative residual is below tol. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. g���ư>Nru r r" ) r* r� r� r� r r� r� r� Zmaximumr� r� Zsqrtr� )r� rp r� r� �maxiterr� Zb_normZkvecr �r�w�pZbetaZrho�kr r` Zrhooldr� r r r r� s8 ! " r� c C s^ | j dkst�| jdd� dks$t�t�| �}| dd�ddf | dd�ddf }|| dd�ddf | dd�ddf }t�|�dt�|� k}t�|�r�d| }n t�| jd �}d|| ||< | dd�ddf | |dd�ddf< | dd�ddf | |dd�ddf< | dd�ddf | |dd�ddf< | dd�ddf | |dd�ddf< |S ) z� Inversion of arrays of (2,2) matrices, returns 0 for rank-deficient matrices. *M* : array of (2,2) matrices to inverse, shape (n,2,2) r| ���N�r# r# r r" �:�0�yE>r )ri r� r r r� r� �allr� )r �M_inv�prod1�delta�rank2Z delta_invr r r r� � s $( $&&$r� c C sj | j dkst�| jdd� dks$t�t�| �}| dd�ddf | dd�ddf }|| dd�ddf | dd�ddf }t�|�dt�|� k}t�|��r6| dd�ddf | |dd�ddf< | dd�ddf | |dd�ddf< | dd�ddf | |dd�ddf< | dd�ddf | |dd�ddf< �n0|| }| |ddf | ||ddf< | |ddf | ||ddf< | |ddf | ||ddf< | |ddf | ||ddf< | }| |ddf | |ddf }t�|�dk }d| |d | }| |ddf | ||ddf< | |ddf | ||ddf< | |ddf | ||ddf< | |ddf | ||ddf< |S ) a� Inversion of arrays of (2,2) SYMMETRIC matrices; returns the (Moore-Penrose) pseudo-inverse for rank-deficient matrices. In case M is of rank 1, we have M = trace(M) x P where P is the orthogonal projection on Im(M), and we return trace(M)^-1 x P == M / trace(M)**2 In case M is of rank 0, we return the null matrix. *M* : array of (2,2) matrices to inverse, shape (n,2,2) r| r� Nr� r r" r� r r# )ri r� r r r� r� r� ) r r� r� r� r� Zrank01ZtrZtr_zerosZ sq_tr_invr r r rm � s2 $( $&&( rm c C s� | j }|j }t|�dks t�t|�dks,t�|d |d ks@t�t|�}t|d �|d |d f�}t�t�| |�dtjf |dtjdd�f d�S )zm Matrix product between arrays of matrices, or a matrix and an array of matrices (*M1* and *M2*) r# r! r� r" .N���)r �lenr� r� r �sum� transpose�newaxis)r� r� Zsh1Zsh2Zndim1Zt1_indexr r r rl � s ��rl c C s | dd�t jt jf | S )z6 Scalar product between scalars and matrices. N)r r� )Zscalarr r r r r� � s r� c C s t �| dddg�S )z4 Transposition of an array of matrices *M*. r r# r" )r r� )r r r r rk � s rk c C s |dks t �| j}|dks t �|j}|dks0t �| j}|dd� \}}|d |jd ks\t �tj|d tjd�}t�| �} |dkr�t|�D ]8} t|�D ]*} | || | | | f | dd�| | f< q�q�nL|dk�rt|�D ]8} t|�D ]*} | || | | | f | dd�| | f< q�q�| S )z� Rolls an array of matrices along an axis according to an array of indices *roll_indices* *axis* can be either 0 (rolls rows) or 1 (rolls columns). �r r" r| r" r� Nr r )r� ri r r r� r� r� r� ) r Z roll_indicesrY ri Z ndim_roll�shr� rs Z vec_indicesZM_roll�ir�icr r r r~ � s& , *r~ c C s� t | ttf�st�tdd� | D ��s(t�t�dd� | D ��}t�||d dk�sVt�t| �}|d }t�| d d �}|j}|j d ||g}tj ||d�}t |�D ]2}t |�D ]$} t�| | | �|dd�|| f< q�q�|S )z� Builds an array of matrices from individuals np.arrays of identical shapes. *M*: ncols-list of nrows-lists of shape sh. Returns M_res np.array of shape (sh, nrow, ncols) so that: M_res[...,i,j] = M[i][j] c s s | ]}t |ttf�V qd S r@ )r �tuple�list��.0�itemr r r � <genexpr>& s z(_to_matrix_vectorized.<locals>.<genexpr>c S s g | ] }t |��qS r )r� r� r r r � <listcomp>' s z)_to_matrix_vectorized.<locals>.<listcomp>r r N) r r� r� r� r� r r r� r r r, r� ) r Zc_vecr� rs ZM00�dtr� ZM_retZirowZicolr r r rn s $rn c C s� |j dkst�|dkst�| j\}}|dkr>|jd ||g}n|dkrV|jd ||g}| j}tj||d�}|dkr�t|�D ].} | || | dd�f |dd�| dd�f< qzn@|dkr�t|�D ].} | dd�|| | f |dd�dd�| f< q�|S )z� Extracts selected blocks of a matrices *M* depending on parameters *block_indices* and *block_size*. Returns the array of extracted matrices *Mres* so that: M_res[...,ir,:] = M[(block_indices*block_size+ir), :] r" r� r r N)ri r� r r r r, r� ) r Z block_indicesr� rY r� rs r� r ZM_resr� r� r r r r� 5 s . ,r� )Nr� r� ) r= Znumpyr Z matplotlibr Zmatplotlib.trir Zmatplotlib.tri.trifinderr Zmatplotlib.tri.tritoolsr �__all__�objectr r r rU r� re rf rg r� r� r� rm rl r� rk r~ rn r� r r r r �<module> s< ^8 / %D U;H y /