a Sic@sdZddlZddlmZddlmZddlmZddl m Z dZ Gdd d Z Gd d d e Z Gd d d e ZGdddZGdddZGdddeZGdddeZGdddeZGdddZd,ddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+ZdS)-z( Interpolation inside triangular grids. N)_api) Triangulation) TriFinder) TriAnalyzer)TriInterpolatorLinearTriInterpolatorCubicTriInterpolatorc@s4eZdZdZd ddZdZdZd dd Zd d ZdS)ram Abstract base class for classes used to interpolate on a triangular grid. 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). NcCsrtjt|d||_t||_|jj|jjjkr:t dtjt df|d|pX|j |_ d|_ d|_d|_dS)N) triangulationz=z array must have same length as triangulation x and y arrays) trifinder?)rcheck_isinstancer_triangulationnpasarray_zshapex ValueErrorr get_trifinder _trifinder_unit_x_unit_y _tri_renumselfr zr rY/var/www/html/django/DPS/env/lib/python3.9/site-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 ------- 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}`. rc Cstj|tjd}tj|tjd}|j}|j|jkrFtd|j|jt|}t|}||j}||j}t |}|dur| ||}n&|j|krtd|j|t|}|dk} |j dur|| } n|j || } || } || } g} |D]}zdddd |}Wn0t y>}ztd |WYd}~n d}~00d d |jd |jg|}tj |tjd}tj|| <||| | | ||| <| tjj||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 where interpolated values are requested. tri_index : array-like of int, 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 ------- 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}rrdzdxdzdyzd9d:Zd;d<Zd=S)?rfaN 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) ) rr@rrrrrr) пrr??rrrrr) rrrrrrrrrr) rr rr@rrrr) rrrr?rr rrr) rrrrr rrrr ) rrr rrrrrrr) rrrrrrrrr r ) rrrrrrrr rr) rrrrrrrrrr) rr?rrrrr) rrr?rrrrrr) r rrrrrrrrr) rrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrrr rr)r rr)rr r)rrr )r r r )rr)rrr )qq?qq?qq?)rrr)98?rr)rrr)rrr)rrr)rrr)rrr)rrrr g"@)rr@c Cs|tj|dddddf}t|| dd}t|| dd}|ddddf}|ddddf}|ddddf} ||} ||} | | } t| |g| |g| | g| | g| |g| |g| | g| |g| |g||| gg } |j| }|t|ddddf|j| 7}|t|ddddf|j| 7}|t|ddddf|j| 7}t|d|dd}||ddddfS)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#rhNrr$) rargmin_roll_vectorizedr|M_scalar_vectorizedM0M1M2)rrprqdofssubtrirErr4rx_sqy_sqz_sqVprodsrrrrls&0$ """z'_ReducedHCT_Element.get_function_valuescCstj|dddddf}t|| dd}t|| dd}|ddddf}|ddddf} |ddddf} ||} | | } | | } td| d| gd| dgdd| gd || d || | gd || | d || gd || | | gd | | | g| d | | g| d || | g|| | | || | | gg }|t|j|ddd }|j|}|t|ddddf|j|7}|t|ddddf|j |7}|t|ddddf|j |7}t|d |dd}||}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#rhNrr$rrrrr block_sizerir) rrrr|_extract_submatrices rotate_dVrrrrr_safe_inv22_vectorizedrz)rrprsrqrrrrrr4rrrrZdVrZdsdksidfdksiJ_invZdfdxrrrrnsB     """ z,_ReducedHCT_Element.get_function_derivativesc Cs.|||}||}||}||}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_d2Sidksij2get_Hrot_from_Jrz) rrprsrqrd2sdksi2Zd2fdksi2H_rotZd2fdx2rrrget_function_hessianss   z)_ReducedHCT_Element.get_function_hessiansc Cstj|dddddf}t|| dd}t|| dd}|ddddf}|ddddf}|ddddf}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|j|d dd } |j| } | t|ddddf|j| 7} | t|ddddf|j | 7} | t|ddddf|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#rhNrr$g@rrg@rrr) rrrr|r rotate_d2Vrrrrr) rrprqrrrrr4rZd2Vrrrrrrs6  $$   """z"_ReducedHCT_Element.get_d2Sidksij2cCszt|d}|j|}|j|}tj|ddgtjd}d|ddddf<d|ddddf<d|ddddf<||ddddddf<||ddddddf<||ddd dd df<|j|d d \}}tj|ddgtjd} |j} |j} t |j D]f} t | | ddf| |d} t | d } | | }|| |}||}| |||jt|7} qt|| |} 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 rrr r#NrT) return_arear$)rr,J0_to_J1J0_to_J2zerosr)rgauss_w gauss_ptsrangen_gausstiler3rkrrrzr)rrsrqnJ1J2ZDOF_rotrareaKweightsptsZigaussrpweightZ d2Skdksi2Zd2Skdx2rrrget_bending_matrices>s.      z(_ReducedHCT_Element.get_bending_matricesFc Cst|}|ddddf}|ddddf}|ddddf}|ddddf}t||||||g||||||gd||d||||||gg}|s|Sd|ddddf|ddddf|ddddf|ddddf} || fSdS)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)) Nrr#r$r)rr|) rrsrrZJi00ZJi11ZJi10ZJi01rrrrrrqs$Lz#_ReducedHCT_Element.get_Hrot_from_Jc Cst|d}tj|tjd}tj|dtjd}gd}gd} t||dddfd|dddfdd||dddfd|dddfdd||dddfd|dddfddg g} tj|d dgtjd} t| | } | | } |||}t |t |||}t | t |||}t | t |||}|t ||| }tj |dd }||dddddf }| t |dg|dddddf}tj t |t |d }||||fS) aF Build K and F for the following elliptic formulation: minimization of curvature energy with value of function at node imposed and derivatives 'free'. Build the global Kff matrix in cco format. Build 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 rr r")r#r$rr)rrrNr$r#rrhr) rr,arangeint32fullr|onesrzrr+ix_rkbincount)rrsrq trianglesUcZntriZ vec_rangeZ c_indicesZf_dofZc_dofZ f_dof_indicesZexpand_indicesZ f_row_indicesZ f_col_indicesZK_elemKff_valsKff_rowsKff_colsZKfc_elemZUc_elemZFf_elemZ Ff_indicesFfrrrget_Kff_and_Ffs. ***  &z"_ReducedHCT_Element.get_Kff_and_FfN)F)r@rArBrCrrrrrrrrrr)rrrrrrrlrnrrrrrrrrrrfBs        "8)3 rfc@s4eZdZdZddZddZddZedd Zd S) _DOF_estimatoral Abstract base class for classes used to estimate a function's 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. cKs^tjt|d|j|_|j|_|j|_|j|_|j|j |_|_ |j fi||_ | dS)N) interpolator) rr rr`rarrr]rr compute_dzr[rw)rrkwargsrrrrs z_DOF_estimator.__init__cKstdSrFr=)rrrrrrsz_DOF_estimator.compute_dzcCs6t|j}|j|j}|j|j}||||}|S)zU Compute reduced-HCT elements degrees of freedom, from the gradient. )rrmrarr]r[ get_dof_vec)rrstri_ztri_dzZtri_dofrrrrws    z"_DOF_estimator.compute_dof_from_dfc Csh|jd}tj|dgtjd}tj|}tj|}|tj|dddddfdd}|tj|dddddfdd}|tj|dddddfdd} t|ddddf|ddddf| ddddfg|ddddf|ddddf| ddddfgg} ||ddddd f<| dddf|dddd d f<| dddf|ddddd f<|S) a\ Compute the dof vector of a triangle, from the value of f, df and of the local Jacobian at each node. Parameters ---------- tri_z : shape (3,) array f nodal values. tri_dz : shape (3, 2) array df/dx, df/dy nodal values. J Jacobian matrix in local basis of apex 0. Returns ------- dof : shape (9,) array For each apex ``iapex``:: dof[iapex*3+0] = f(Ai) dof[iapex*3+1] = df(Ai).(AiAi+) dof[iapex*3+2] = df(Ai).(AiAi-) rrr Nr$rhr#rrr) rrrr)rfrrrkr|) rrrsnptrrrrZcol0Zcol1Zcol2rrrrrs   $$$22""z_DOF_estimator.get_dof_vecN) r@rArBrCrrrwrrrrrrrs    rc@seZdZdZddZdS)rtz3dz is imposed by user; accounts for scaling if any.cCs,|\}}||j}||j}t||gjSrF)rrrvstackT)rr[r&r'rrrr(s  z_DOF_estimator_user.compute_dzN)r@rArBrCrrrrrrt%srtc@s(eZdZdZddZddZddZdS) ruz=Fast 'geometric' approximation, recommended for large arrays.c Cs|}|}tjt|jt|d}t|}t|}tdD]\}|dd|f|dddf|dd|f<|dd|f|dddf|dd|f<qHtjt|jt|d}tjt|jt|d}||} ||} t| | gj 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 rrNrr#) compute_geom_weightscompute_geom_gradsrrr+r] empty_likerrr) rZ el_geom_wZ el_geom_gradZ w_node_sumZdfx_el_wZdfy_el_wZiapexZ dfx_node_sumZ dfy_node_sumZ dfx_estimZ dfy_estimrrrr2s&    ,.z_DOF_estimator_geom.compute_dzc CsFtt|jddg}|j}tdD]}|dd|dddf}|dd|ddddf}|dd|ddddf}t|dddf|dddf|dddf|dddf}t|dddf|dddf|dddf|dddf}t||tjd} dt| d|dd|f<q&|S)z Build the (nelems, 3) weights coeffs of _triangles angles, renormalized so that np.sum(weights, axis=1) == np.ones(nelems) rrNr#r) rrr,r]rararctan2abspi) rrroZiptp0p1p2Zalpha1Zalpha2anglerrrrSsDD z(_DOF_estimator_geom.compute_geom_weightsc Cs~|j}|j|j}|dddddf|dddddf}|dddddf|dddddf}t||g}t|}|dddf|dddf}|dddf|dddf}t||gj} t| } | dddf|ddddf| dddf|ddddf| dddf<| dddf|ddddf| dddf|ddddf| dddf<| 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#rr$) rarr]rdstackrrrr) rroZtris_fZdM1ZdM2ZdMZdM_invZdZ1ZdZ2ZdZdfrrrris ,,   PPz&_DOF_estimator_geom.compute_geom_gradsN)r@rArBrCrrrrrrrru/s!rucs,eZdZdZfddZfddZZS)rvz 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] cs|j|_t|dSrF)rcrGr)rZ InterpolatorrJrrrsz_DOF_estimator_min_E.__init__cst}t|}t}t|j}|j}|j }|j |j }| ||||\}} } } d} | j d} t | || | | fd}|t|| || d\}}tj||| }||krtd|}tj|jj ddgtjd}|ddd|dddf<|d dd|ddd f<|S) z{ Elliptic solver for bending energy minimization. Uses a dedicated 'toy' sparse Jacobi PCG solver. 绽|=r)r)Ar~x0tolzIn TriCubicInterpolator initialization, PCG sparse solver did not converge after 1000 iterations. `geom` approximation is used instead of `min_E`r$r Nr#)rGrrr+rfrrmrarcr]rrr_Sparse_Matrix_coo compress_csc_cglinalgnormdotr warn_externalr.r`r))rZdz_initZUf0Zreference_elementrsZeccsrrrrrrrZn_dofZKff_cooZUfr:Zerr0r[rJrrrs2       z_DOF_estimator_min_E.compute_dz)r@rArBrCrrrUrrrJrrvs rvc@sHeZdZddZddZddZddZd d Zd d Ze d dZ dS)rcCsF|\|_|_tj|tjd|_tj|tjd|_tj|tjd|_dS)a4 Create 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) rmrrr)valsrrowscols)rrrrrrrrrs z_Sparse_Matrix_coo.__init__cCs2|j|jfksJtj|j|j||j|jdS)z Dot product of self by a vector *V* in sparse-dense to dense format *V* dense vector of shape (self.m,). )r minlength)rrrrrrr)rrrrrrs z_Sparse_Matrix_coo.dotcCsRtj|j|j|jddd\}}}|j||_|j||_tj||jd|_dS)zV Compress rows, cols, vals / summing duplicates. Sort for csc format. Tr9return_inverserN)runiquerrrrrr_rindicesrrrrs   z_Sparse_Matrix_coo.compress_csccCsRtj|j|j|jddd\}}}|j||_|j||_tj||jd|_dS)zV Compress rows, cols, vals / summing duplicates. Sort for csr format. TrrN)rrrrrrrrrrr compress_csrs   z_Sparse_Matrix_coo.compress_csrcCsXtj|j|jgtjd}|jj}t|D]*}||j||j |f|j|7<q(|S)zY Return a dense matrix representing self, mainly for debugging purposes. r ) rrrrr)rr,rrr)rr7nvalsirrrto_denses  (z_Sparse_Matrix_coo.to_densecCs |SrF)r __str__)rrrrr sz_Sparse_Matrix_coo.__str__cCs>|j|jk}tjt|j|jtjd}|j|||j|<|S)z3Return the (dense) vector of the diagonal elements.r )rrrrminrr)r)rZin_diagdiagrrrrs z_Sparse_Matrix_coo.diagN) r@rArBrrrr r r propertyrrrrrrs     rrcCs4|j}|j|ksJ|j|ks"Jtj|}|j}t|d}|durTt|}n|}|| |} | |} t|} d} t | | } d}t t | ||kr||kr| | | } | | }| t | |}| ||} | |} | }t | | } ||| }| |} |d7}qtj| ||}||fS)a Use Preconditioned Conjugate Gradient iteration to solve A x = b A simple Jacobi (diagonal) preconditioner 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. x0 : array, optional Starting guess for the solution. Defaults to the zero vector. tol : float, optional Tolerance to achieve. The algorithm terminates when the relative residual is below tol. Default is 1e-10. maxiter : int, optional Maximum number of iterations. Iteration will stop after *maxiter* steps even if the specified tolerance has not been achieved. Defaults to 1000. Returns ------- x : array The converged solution. err : float The absolute error np.linalg.norm(A.dot(x) - b) gư>Nrrr#) r,rrrrrrmaximumrrsqrtr)rr~rrmaxiterrZb_normZkvecrrwpbetarhokrrpZrhooldr:rrrrs8     "      rcCsHtjd|dt|}|ddddf|ddddf}||ddddf|ddddf}t|dt|k}t|rd|}n t|jd}d||||<|ddddf||ddddf<|ddddf ||ddddf<|ddddf ||ddddf<|ddddf||ddddf<|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) Nr$r$rNrr#:0yE>r )r check_shaperrrallrr)rM_invprod1deltarank2Z delta_invrrrrws $(  $&&$rc CsTtjd|dt|}|ddddf|ddddf}||ddddf|ddddf}t|dt|k}t|r |ddddf||ddddf<|ddddf ||ddddf<|ddddf ||ddddf<|ddddf||ddddf<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) rrNrr#rr r$)rrrrrr) rr r!r"r#Zrank01trZtr_zerosZ sq_tr_invrrrr{s0  $( $&&(r{cCs|ddtjtjf|S)z6 Scalar product between scalars and matrices. N)rnewaxis)scalarrrrrrsrcCst|gdS)z4 Transposition of an array of matrices *M*. )rr$r#)r transposerrrrrzsrzc Cs |dvs J|j}|dksJ|j}|dks0J|j}|dd\}}|d|jdks\Jtj|dtjd}t|} |dkrt|D]8} t|D]*} ||| | || f| dd| | f<qqnBt|D]8} t|D]*} ||| | | |f| dd| | f<qq| S)z{ Roll an array of matrices along *axis* (0: rows, 1: columns) according to an array of indices *roll_indices*. rr#rr#Nrr )rxrrrrrr) rZ roll_indicesrirxZ ndim_rollshrrZ vec_indicesZM_rolliricrrrrs$      ,  *rc Cst|ttfsJtdd|Ds(Jtdd|D}t||ddksVJt|}|d}t|dd}|j}|jd||g}tj ||d}t |D]2}t |D]$} t||| |dd|| f<qq|S)a+ Build an array of matrices from individuals np.arrays of identical shapes. Parameters ---------- M ncols-list of nrows-lists of shape sh. Returns ------- M_res : np.array of shape (sh, nrow, ncols) *M_res* satisfies ``M_res[..., i, j] = M[i][j]``. css|]}t|ttfVqdSrF) isinstancetuplelist.0itemrrr z(_to_matrix_vectorized..cSsg|] }t|qSr)lenr0rrr r4z)_to_matrix_vectorized..rr N) r-r.r/rrrr5r!rr.r) rZc_vecrrZM00dtr*ZM_retZirowicolrrrr|s  $r|c Cs|jdksJ|dvsJ|j\}}|dkr>|jd||g}n|jd||g}|j}tj||d}|dkrt|D].} |||| ddf|dd| ddf<qrn8t|D].} |dd||| f|dddd| f<q|S)z Extract 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(rr N)rxrr!rr.r) rZ block_indicesrrirrr*r7ZM_resr+r,rrrr s    . ,r)Nrr)rCnumpyr matplotlibrmatplotlib.trirmatplotlib.tri.trifinderrZmatplotlib.tri.tritoolsr__all__rrrrfrrtrurvrrrr{rrzrr|rrrrrs:    Z6&L U;D t.