h6SrSSKrSSKJr SSKJr SSKJr SSK J r Sr "SS 5r "S S \ 5r "S S \ 5r"SS5r"SS5r"SS\5r"SS\5r"SS\5r"SS5rS"SjrSrSrSrSrSrS rS!rg)#z( Interpolation inside triangular grids. N)_api) Triangulation) TriFinder) TriAnalyzer)TriInterpolatorLinearTriInterpolatorCubicTriInterpolatorc>\rSrSrSrS SjrSrSrS SjrSr S r g) ra= 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). Nc[R"[US9 Xl[R "U5UlUR RURRR:wa [S5e[R"[S4US9 U=(d URR5Ul SUl SUlSUlg)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_renum)selfr zrs P/var/www/html/env/lib/python3.13/site-packages/matplotlib/tri/_triinterpolate.py__init__TriInterpolator.__init__!s m=I+**Q- 77==D//1177 7-. . y$/9E#Jt':':'H'H'J   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}`. c[R"U[RS9n[R"U[RS9nURnURUR:wa%[ SURSUR35e[R "U5n[R "U5nXR - nX R- n[R"U5nUcURX5nOAURU:wa[ SURSU35e[R "U5nUS:gn URcX9n OURX9n Xin Xyn /n UHnSSS S .UnS S UR - S UR- /Un[R"U[RS9n[RUU )'URXX5U-UU 'U [RR!UR#U5S S9/- n M U $![an[ S 5UeSnAff=f)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. dtypez'x and y shall have same shapes. Given: z and NzItri_index array is provided and shall have same shape as x and y. Given: rrdzdxdzdyz\\>778$  -I&( ; 'uVH677+I? ?? "'0O"ooi.@AO##%J D%&1=jI DLL"T\\/:<HEhhxrzz:G "GWH #;;W ?AF GGG  BEE(()@u(MN NC!&$  D ":;@CD Ds> H// I 9 II c[S5e)a Interpolate at points belonging to the triangulation (inside an unmasked triangles). Parameters ---------- return_key : {'z', 'dzdx', 'dzdy'} The requested values (z or its derivatives). tri_index : 1D int array Valid triangle index (cannot be -1). x, y : 1D arrays, same shape as `tri_index` Valid locations where interpolation is requested. Returns ------- 1-d array Returned array of the same size as *tri_index* zCTriInterpolator subclassesshould implement _interpolate_single_key!NotImplementedErrorrrCr8rr7s rr3'TriInterpolator._interpolate_single_keys&"#NO Or")rrrrrrN)Nr) __name__ __module__ __qualname____firstlineno____doc__r _docstring__call___docstringgradientrHr3__static_attributes__r"rrrs1": $ ,6:+1iVOr"rc^\rSrSrSrSU4SjjrSr\R\lSr \R\ lSr Sr U=r $) raf Linear interpolator 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 : `~matplotlib.tri.Triangulation` The triangulation to interpolate over. z : (npoints,) array-like Array of values, defined at grid points, to interpolate between. trifinder : `~matplotlib.tri.TriFinder`, optional If this is not specified, the Triangulation's default TriFinder will be used by calling `.Triangulation.get_trifinder`. Methods ------- `__call__` (x, y) : Returns interpolated values at (x, y) points. `gradient` (x, y) : Returns interpolated derivatives at (x, y) points. cz>[TU]XU5 URRUR5UlgrO)superr rcalculate_plane_coefficientsr_plane_coefficients)rr rr __class__s rr LinearTriInterpolator.__init__s4 95    < [T U]XU5 URR5 [ UR5nUR 5upxpn XplXlU S:gn URU URX'[R"U5Ul [R"U 5Ul [R"XR- XR- /5UlURUR UlUR!UR5Ul[$R&"/SQUS9 UR)X5S9Ul[-5Ulg)Nr&)usergeommin_E)kinddz)r]r rget_cpp_triangulationr_get_compressed_triangulation _trianglesrrrptprr column_stack_pts _tris_pts_compute_tri_eccentricities_eccsrrq _compute_dof_dof_ReducedHCT_Element_ReferenceElement)rr rrzrr| tri_analyzercompressed_triangles compressed_x compressed_y tri_renum node_renum valid_noder`s rr CubicTriInterpolator.__init__{s( 95 113#4#6#67 #AAC  \ .# B& *.''**= &'vvl+ vvl+ OO\LL%@%1LL%@%BC 4??355dnnE  44@%%d%2 !4!6r"c*URXSSS9S$rcrerfs rrgCubicTriInterpolator.__call__rir"c$URXSSS9$rkrerfs rrlCubicTriInterpolator.gradientrnr"c[R"/SQUS9 URUnURX4U5nURUn[ R "URUSS9nUS:XaURRXgU5$URU5n URRXiXx5n US:Xa U SS2SS4$U SS2SS4$)Nr)rpr'axisrr*r) rrqr_get_alpha_vecrr expand_dimsrrget_function_values _get_jacobianget_function_derivatives) rrCr8rr7tris_ptsalphaeccdofJr*s rr3,CubicTriInterpolator._interpolate_single_keys 0ZH>>),##A(3jj#nnTYYy1:  ))==C! !""8,A))BB#$DV#Aq!G}$Aq!G}$r"cUS:Xa'Uc [S5e[XS9nUR 5$US:Xa[U5nUR 5$[U5nUR 5$)a Compute and return nodal dofs according to kind. Parameters ---------- kind : {'min_E', 'geom', 'user'} Choice of the _DOF_estimator subclass to estimate the gradient. dz : tuple of array-likes (dzdx, dzdy), optional Used only if *kind*=user; in this case passed to the :class:`_DOF_estimator_user`. Returns ------- array-like, shape (npts, 2) Estimation of the gradient at triangulation nodes (stored as degree of freedoms of reduced-HCT triangle elements). rwzQFor a CubicTriInterpolator with *kind*='user', a valid *dz* argument is expected.r{rx)r_DOF_estimator_user_DOF_estimator_geom_DOF_estimator_min_Ecompute_dof_from_df)rrzr|TEs rr!CubicTriInterpolator._compute_dofs~$ 6>z "9::%T1B %%'' V^$T*B%%''&d+B%%''r"cURS- nUSS2SSS24USS2SSS24- nUSS2SSS24USS2SSS24- n[R"XE/SS9n[U5n[R"X/SS9USS2SSS24- nXv-n [ U 5n U[[R "X55-n X-n [ SU SS2SS4- U SS2SS4- /U SS2SS4/U SS2SS4//5n U $)a 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 ------- array of dim 2 (shape (nx, 3)) Barycentric coordinates of the points inside the containing triangles. r(Nr'rr&r)ndimrstack_transpose_vectorized_pseudo_inv22sym_vectorizedr_to_matrix_vectorized)rr7rrababTabOMmetric metric_invCovarksirs rr#CubicTriInterpolator._get_alpha_vecs&}}Q Q1W Aq 1 1 Q1W Aq 1 1hhvB' "3 ' XXqf1 %Aq(9 9 18 *2>>"+CDD % s1a7|^C1aL ( )C1aL>C1aL>'KL r"c[R"USS2SSS24USS2SSS24- 5n[R"USS2SSS24USS2SSS24- 5n[USS2S4USS2S4/USS2S4USS2S4//5nU$)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 ------- 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'rr()rarrayr)rrrrs rr"CubicTriInterpolator._get_jacobians, HHXaAg&!Q'):: ; HHXaAg&!Q'):: ; !AadGQq!tW#5$%adGQq!tW#5#7 8r"c[R"USS2SSS24USS2SSS24- SS9n[R"USS2SSS24USS2SSS24- SS9n[R"USS2SSS24USS2SSS24- SS9n[U5U-SS2SS4n[U5U-SS2SS4n[U5U-SS2SS4n[Xe- U- /XF- U- /XT- U- //5$)a  Compute triangle eccentricities. Parameters ---------- tris_pts : array like of dim 3 (shape: (nx, 3, 2)) Coordinates of the triangles apexes. Returns ------- array like of dim 2 (shape: (nx, 3)) The so-called eccentricity parameters [1] needed for HCT triangular element. Nr(r'rr)rrrr)rrrcdot_adot_bdot_cs rr0CubicTriInterpolator._compute_tri_eccentricities!s NN8Aq!G,x1a/@@q I NN8Aq!G,x1a/@@q I NN8Aq!G,x1a/@@q I'q)A-q!Qw7&q)A-q!Qw7&q)A-q!Qw7% u'<&=(- u'<&=(- u'<&=&?@ @r") rrrrrrrrr)ryNNrO)rQrRrSrTrUr rgrrVrlrWr3r staticmethodrrrrXrsrts@rr r s[xBF'7RB'99HI'99H%$(<$$L6@@r"r c \rSrSrSr\R "/SQ/SQ/SQ/SQ/SQ/SQ/S Q/S Q/S Q/ 5r\R "/S Q/S Q/S Q/S Q/SQ/S Q/SQ/S Q/SQ/ 5r\R "/SQ/S Q/SQ/S Q/S Q/S Q/SQ/SQ/S Q/ 5r \R "/SQ/SQ/S Q/SQ/S Q/SQ/S Q/S Q/S Q/ 5r \R "SS/SS/SS/SS/SS/SS//5r \R "/SQ/SQ/SQ/SQ/SQ/S Q/SQ/SQ/S!Q/ 5r S"r \R "/S#Q/S$Q/S%Q/S&Q/S'Q/S(Q/S)Q/S*Q/S+Q/ \RS,9r\R "S"/\RS,9S-- r\R "/SQ/SQ/S.Q/5r\R "SS/SS//5r\R "SS/SS//5rS/rS0rS1rS2rS3rS8S4jrS5rS6rg7)9riBa 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) rrrr@rrrr) rrrr?rrrrr) rrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rr?rrrrr) rrr?rrrrrr) rrrrrrrrrr) rrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrr) rrrrrrrrrrrrr)rrr)rrr)rrr)rrr)rr)rrr )qq?qq?qq?)rrr)98?rr)rrr)rrr)rrr)rrr)rrr)rrrr$g"@)rr@c P[R"USS9SS2S4n[X*SS9n[X$*SS9nUSS2SS4nUSS2SS4nUSS2SS4n Xw-n X-n X-n [X-/X-/X-/X-/X-/X-/X-/X-/X-/Xx-U -// 5n URU -nU[ USS2SS4UR U -5- nU[ USS2SS4URU -5- nU[ USS2SS4URU -5- n[USU-SS9nX?-SS2SS4$)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'rNrr() rargmin_roll_vectorizedrM_scalar_vectorizedM0M1M2)rrrdofssubtrirErr7rx_sqy_sqz_sqVprodss rr'_ReducedHCT_Element.get_function_valuessl5q)!Q$/ugA6 S' 2 1aL 1aL 1aLsss ! VHtvh46(TVHtvh VHtvh13q5'#3 4vvz "1Q1W:tww{;; "1Q1W:tww{;; "1Q1W:tww{;; T1V8! 4!Q'""r"c@[R"USS9SS2S4n[X*SS9n[X5*SS9nUSS2SS4nUSS2SS4n USS2SS4n X-n X-n X-n [SU -SU -/SU -S/SSU -/S U-U -S U-U -U -/S U-U -U -S U-U -/S U-U -U - U */S U -U -U /U S U -U -/U *S U-U -U - /X-X-- X-X-- // 5nU[ UR USSS 9-nUR U-nU[USS2SS4URU-5- nU[USS2SS4URU-5- nU[USS2SS4URU-5- n[US U-SS9nUU-n[U5nU[U5-nU$) 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'rNrr(rrrrr block_sizerr) rrrr_extract_submatrices rotate_dVrrrrr_safe_inv22_vectorizedr)rrrrrrrrrr7rrrrdVrdsdksidfdksiJ_invdfdxs rr,_ReducedHCT_Element.get_function_derivativess&&5q)!Q$/ugA6 S' 2 1aL 1aL 1aLsss "Ts4x (T'R (4 (a%'3q574< ( U1WT\Aa (d1fTk4% (a464 (Aa (EBqDF4K (#ac'AC ( $* +& NNFqq::vv{ "1Q1W:tww|<< "1Q1W:tww|<< "1Q1W:tww|<<!$&q9'q),V44 r"clURX5nXE-nURU5nXg-n[U5$)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_Jr) rrrrrd2sdksi2d2fdksi2H_rotd2fdx2s rget_function_hessians)_ReducedHCT_Element.get_function_hessianss>&&&u2?$$Q'!$V,,r"c [R"USS9SS2S4n[X*SS9n[X#*SS9nUSS2SS4nUSS2SS4nUSS2SS4n[SU-SU-SU-/SU-SS/SSU-S/SU-SU-S U-- SU-SU-- /SU-S U-- SU-SU-SU-- /SU-S U-- SS U-/SU-SSU-/SSU-SU-/SSU-S U-- S U-/S U-S U-Xg- U- // 5n U [ UR US SS 9-n UR U -n U [USS2SS4URU -5- n U [USS2SS4URU -5- n U [USS2SS4URU -5- n [U S U-SS9n U $) aK 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'rNrr(g@rrg@rrr) rrrrr rotate_d2Vrrrrr) rrrrrrrr7rd2Vrrs rr"_ReducedHCT_Element.get_d2Sidksij2s5q)!Q$/ugA6 S' 2 1aL 1aL 1aL#Q$RT1 -Q$r" -RT" -Q$1RT 2a419 - T"Q$YRT2a419 - T"Q$Yrs1u -Q$r1 -RT1 -1RT s1u -QCEqs1u - %/ 0( OOV;;vv| "1Q1W:tww}== "1Q1W:tww}== "1Q1W:tww}==#D!F(;r"cL[R"US5nURU-nURU-n[R"USS/[R S9nSUSS2SS4'SUSS2SS4'SUSS2SS4'XSS2SS2SS24'XFSS2SS2SS24'XVSS2S S2S S24'UR US S 9upx[R"USS/[R S9n URn URn [UR5Hn [R"XSS24U5RUS5n [R"U S 5n XnURX5nX-nXUUR-[!U5--- n M [!U5U -U-n [#X5$) 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_gausstiler6rrrrr)rrrnJ1J2DOF_rotrareaKweightsptsigaussrweight d2Skdksi2d2Skdx2s rget_bending_matrices(_ReducedHCT_Element.get_bending_matrices>s GGCO]]Q  ]]Q ((Aq!9BJJ71a1a1a 1Q3! !1Q3! !1Q3! **1$*?  HHaAYbjj 1,,nnDLL)FGGC NA.66q!L!Aq!G*Qq!QwZ/!Aq!G*Qq!QwZ2GGHD; r"c p[R"US5n[R"U[RS9n[R"US[RS9n/SQn/SQn [ XsSS2S4S-USS2S4S-S-XsSS2S4S-USS2S4S-S-XsSS2S4S-USS2S4S-S-/ /5n [R "US S/[RS9n [X-5n X-n URX5n[R"U[R"XhU55n[R"U [R"XhU55n[R"U [R"XhU55nU[R"XhU 5n[R"USS 9nUU-SS2SS2S4*nU [R"US/U5SS2SSS24n[R"[R"U5[R"U5S 9nUUUU4$) a 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(r r )rrrNr(r'rrr) rr/arangeint32fullronesrr r.ix_rbincount)rrr trianglesUcntri vec_range c_indicesf_dofc_dof f_dof_indicesexpand_indices f_row_indices f_col_indicesK_elemKff_valsKff_rowsKff_colsKfc_elemUc_elemFf_elem Ff_indicesFfs rget_Kff_and_Ff"_ReducedHCT_Element.get_Kff_and_Ffs0wwsAIId"((3 GGD"BHH5 ". Aq()AqD/!*;A*= Aq()AqD/!*;A*= Aq()AqD/!*;A*=0?/@A $1RXX>-n.LM &6 **1288F266)E#BCD88M"&&5*IJK88M"&&5*IJK"&&59:..!,w&1a00"266)aS%#@A!Q'J [[*-rxx7H I8R//r"rYN)F)rQrRrSrTrUrrrrrrrrrr-rr/rrr r rrrrr rrFrXrYr"rrrBs * GGGGGGGGG I JA HHHHHHHHH J KB FFFFFFFFF H IB FFFFFFFFF H IBB*Rj*sCj*Rj23I<''HIJG5555555557?AjjJIggqc,r1G , l;t')""5!4r"c nURSn[R"US/[RS9n[R U-n[R U-nU[R"USS2SSS24SS9-nU[R"USS2SSS24SS9-nU[R"USS2SSS24SS9-n [USS2SS4USS2SS4U SS2SS4/USS2SS4USS2SS4U SS2SS4//5n XSS2SSS 24'U SS2S4USS2SS S 24'U SS2S4USS2SSS 24'U$) 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(rr'r rr*) rrrr-rr r rr) rSrTrnptrrrcol0col1col2rs rrR_DOF_estimator.get_dof_vecsS0kk!nhhQxrzz2 ) )A - ) )A -2>>&Aq/::BNN6!Q'?;;BNN6!Q'?;;& !Q']DAqM41a= 9 !Q']DAqM41a= 9(;<Aq1uH q!t Aq1uH q!t Aq1uH  r")rrrrrr|rN) rQrRrSrTrUr rLrrrRrXrYr"rrIrIs* #"&&r"rIc\rSrSrSrSrSrg)ri%z3dz is imposed by user; accounts for scaling if any.cUup#X R-nX0R-n[R"X#/5R$rO)rrrvstackT)rr|r*r+s rrL_DOF_estimator_user.compute_dz(s8 ll"ll"yy$&(((r"rYN)rQrRrSrTrUrLrXrYr"rrr%s =)r"rc*\rSrSrSrSrSrSrSrg)ri/z=Fast 'geometric' approximation, recommended for large arrays.c"UR5nUR5n[R"[R"UR 5[R"U5S9n[R "U5n[R "U5n[S5H7nUSS2U4USS2S4-USS2U4'USS2U4USS2S4-USS2U4'M9 [R"[R"UR 5[R"U5S9n[R"[R"UR 5[R"U5S9nXs- n X- n [R"X/5R$)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+rNrr') compute_geom_weightscompute_geom_gradsrr1r.r empty_likerr_r`) r el_geom_w el_geom_grad w_node_sumdfx_el_wdfy_el_wiapex dfx_node_sum dfy_node_sum dfx_estim dfy_estims rrL_DOF_estimator_geom.compute_dz2s?--/ ..0 [[$//!:)+))<> ==+==+1XE!*1e8!4\!Q$5G!GHQX !*1e8!4\!Q$5G!GHQX {{288DOO#<+-88H+=? {{288DOO#<+-88H+=? !+  + yy)/0222r"c[R"[R"URS5S/5nURn[ S5HnUSS2US-SS24nUSS2US-S-SS24nUSS2US- S-SS24n[R "USS2S4USS2S4- USS2S4USS2S4- 5n[R "USS2S4USS2S4- USS2S4USS2S4- 5n[R"X- [R- S-5n S[R"U S- 5- USS2U4'M U$)z| Build the (nelems, 3) weights coeffs of _triangles angles, renormalized so that np.sum(weights, axis=1) == np.ones(nelems) rrNr'r) rrr/rrrarctan2abspi) rrriptp0p1p2alpha1alpha2angles rrd(_DOF_estimator_geom.compute_geom_weightsSs? ((BGGDOOQ7;<>>8C!S1Wa-(B!c!eq[!+,B!c!eq[!+,BZZ1a4AqD 12ad8Bq!tH3DEFZZ1a4AqD 12ad8Bq!tH3DEFFFV]bee3q89E"BFF59$55GAsFOr"crURnURURnUSS2SSS24USS2SSS24- nUSS2SSS24USS2SSS24- n[R"X4/5n[ U5nUSS2S4USS2S4- nUSS2S4USS2S4- n[R "Xx/5Rn [R"U 5n U SS2S4USS2SS4-U SS2S4USS2SS4--U SS2S4'U SS2S4USS2SS4-U SS2S4USS2SS4--U SS2S4'U $)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() rrrrdstackrr_r`rf) rrtris_fdM1dM2dMdM_invdZ1dZ2dZdfs rre&_DOF_estimator_geom.compute_geom_gradsisZ >>(q!Qw(1a7"33q!Qw(1a7"33 YYz "(+QTlVAqD\)QTlVAqD\) YYz " $ $ ]]2 ad8F1a7O+bAhvaAg.FF1a4ad8F1a7O+bAhvaAg.FF1a4 r"rYN) rQrRrSrTrUrLrdrerXrYr"rrr/sG3B,r"rc8^\rSrSrSrU4SjrU4SjrSrU=r$)riz 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] cF>URUl[TU] U5 grO)rr]r )r Interpolatorr`s rr _DOF_estimator_min_E.__init__s!''  &r"c>[TU]5n[R"U5n[ 5n[ R UR5nURnURnURURnURXEXg5uppSn U RSn [XU X4S9nUR5 [XX,S9unn[R R#UR%U5U - 5nUU:a[&R("S5 Un[R*"UR,RSS/[R.S9nUSSS2USS2S4'US SS2USS2S 4'U$) zc Elliptic solver for bending energy minimization. Uses a dedicated 'toy' sparse Jacobi PCG solver. 绽|=r)r)Arx0tolzIn TriCubicInterpolator initialization, PCG sparse solver did not converge after 1000 iterations. `geom` approximation is used instead of `min_E`r(r$Nr')r]rLrr.rr rrrrrrFr_Sparse_Matrix_coo compress_csc_cglinalgnormdotr warn_externalr1rr-)rdz_initUf0reference_elementreccsr2r3r?r@r>rErn_dofKff_cooUfrEerr0r|r`s rrL_DOF_estimator_min_E.compute_dzs\ '$&hhw/1 . .t~~ >zzOO VVDOO $,=+K+K Y,$(H $X,1>;#7Cyy~~gkk#.34 #:    9 :BXXtyyq)1-RZZ @cc71a4add81a4 r")r) rQrRrSrTrUr rLrXrsrts@rrrs ',,r"rcH\rSrSrSrSrSrSrSrSr \ S5r S r g ) ricUuUlUl[R"U[RS9Ul[R"U[R S9Ul[R"U[R S9Ulg)a 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-valsr-rowscols)rrrrrs rr _Sparse_Matrix_coo.__init__sSJJt2::6 JJt2884 JJt2884 r"cURUR4:Xde[R"URUR XR -URS9$)zj Dot product of self by a vector *V* in sparse-dense to dense format *V* dense vector of shape (self.m,). )r minlength)rrrr1rrr)rrs rr_Sparse_Matrix_coo.dotsL ww466)###{{499#'99Qyy\#9%)VV- -r"c[R"URURUR--SSS9upnURUUlURUUl[R "X0R S9Ulg)zF Compress rows, cols, vals / summing duplicates. Sort for csc format. TrDreturn_inverser+N)runiquerrrr1rr_rindicess rr_Sparse_Matrix_coo.compress_cscsk YY IItyy( (d47IIf% IIf% KK; r"c[R"URUR-UR-SSS9upnURUUlURUUl[R "X0R S9Ulg)zF Compress rows, cols, vals / summing duplicates. Sort for csr format. Trr+N)rrrrrr1rrs r compress_csr_Sparse_Matrix_coo.compress_csrsk YY FF499 tyy (d47IIf% IIf% KK; r"c2[R"URUR/[RS9nUR R n[U5H8nXRUURU4==UR U- ss'M: U$)zI Return a dense matrix representing self, mainly for debugging purposes. r$) rrrrr-rr/rrr)rrBnvalsis rto_dense_Sparse_Matrix_coo.to_densesphh'rzz: uA  ! diil* +tyy| ; + r"c>UR5R5$rO)r__str__)rs rr_Sparse_Matrix_coo.__str__s}}&&((r"cURUR:Hn[R"[ UR UR 5[R S9nURUX RU'U$)z3Return the (dense) vector of the diagonal elements.r$)rrrrminrr-r)rin_diagdiags rr_Sparse_Matrix_coo.diagsX99 )xxDFFDFF+2::>#'99W#5YYw   r")rrrrrN) rQrRrSrTr rrrrrpropertyrrXrYr"rrrs4 5- < <)r"rcURnURU:XdeURU:Xde[RR U5nUR n[R"US5nUc[R"U5nOUnXRU5- n X- n [R"U5n Sn [R"X5n Sn[R"[U 55X6-:aX:aXU --n URU 5nU [R"X5- nU UU-- n X- n U n[R"X5n UUU --nU U- n US- n[R"[U 55X6-:aX:aM[RR URU5U- 5nUU4$)a8 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ư>rrr') r/rrrrrrmaximumrrsqrtrt)rrrrmaxiterrb_normkvecrrwpbetarhokrrrhooldrEs rrrs}: A 33!8O8 33!8O8 YY^^A F 66D ::dD !D z HHQK  EE!H A A  A D &&,C A 773s8 sz ) QJ EE!HBFF1L  aK FffQl aK6z Q 773s8 sz )  ))..qA &C c6Mr"cZ[R"SUS9 [R"U5nUSS2SS4USS2SS4-nX SS2SS4USS2SS4-- n[R"U5S[R"U5-:n[R "U5(aSU- nO,[R "URS5nSX4- XT'USS2SS4U-USS2SS4'USS2SS4*U-USS2SS4'USS2SS4*U-USS2SS4'USS2SS4U-USS2SS4'U$)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_shaperrfrtallrr)rM_invprod1deltarank2 delta_invs rrrws? \Q' MM! E aAgJqAqz !E aAgJqAqz) )EVVE]T"&&-/ /E vve}}uH HHQWWQZ( el? q!QwZ )E!Q'N1aj[*E!Q'N1aj[*E!Q'Nq!QwZ )E!Q'N Lr"ch[R"SUS9 [R"U5nUSS2SS4USS2SS4-nX SS2SS4USS2SS4-- n[R"U5S[R"U5-:n[R "U5(aXUSS2SS4U- USS2SS4'USS2SS4*U- USS2SS4'USS2SS4*U- USS2SS4'USS2SS4U- USS2SS4'U$X4nXSS4U- XSS4'XSS4*U- XSS4'XSS4*U- XSS4'XSS4U- XSS4'U)nXSS4XSS4-n[R"U5S:nSU- US-U-- nXSS4U-XSS4'XSS4U-XSS4'XSS4U-XSS4'XSS4U-XSS4'U$) 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'rrr()rrrrfrtr) rrrrrrank01trtr_zeros sq_tr_invs rrrsC \Q' MM! E aAgJqAqz !E aAgJqAqz) )E VVE]T"&&-/ /E vve}}1a7e+aAgAq!G*u,aAgAq!G*u,aAg1a7e+aAg* L! a{^e3Qkq! n_u4Qkq! n_u4Qka{^e3Qk q!|_qA .FF2J&[RU8^4 1 o 9al1 o 9al1 o 9al1 o 9al Lr"cTUSS2[R[R4U-$)z. Scalar product between scalars and matrices. N)rnewaxis)scalarrs rrrs# !RZZ+ ,Q ..r"c4[R"U/SQ5$)z, Transposition of an array of matrices *M*. )rr(r')r transposers rrrs <<9 %%r"c&US;deURnUS:XdeURnUS:XdeURnUSSupgUSURS:Xde[R"US[RS9n[R "U5n US:Xa;[ U5H*n [ U5Hn XU*U -U-U 4U SS2X4'M M, U $[ U5H)n [ U5Hn XX*U -U-4U SS2X4'M M+ U $)zo Roll an array of matrices along *axis* (0: rows, 1: columns) according to an array of indices *roll_indices*. rr'rr'Nrr$)rrrr,r-rfr) r roll_indicesrr ndim_rollshrr vec_indicesM_rollirics rrrs, 6>> 66D 199!!I >> B bc7DA a5L&&q) )) )))BqE2K]]1 F qy(BAh$%\M"4D3I2&M$Nq"y! M(BAh$%2 b8HA7M&M$Nq"y! Mr"cl[U[[45(de[SU55(de[R "UVs/sHn[ U5PM sn5n[R"X"S- S:H5(de[ U5nUSn[R "USS5nURnURSX4/n[R"XvS9n[U5H7n [U5H%n [R "X U 5USS2X4'M' M9 U$s snf)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]``. c3N# UHn[U[[45v M g7frO) isinstancetuplelist).0items r (_to_matrix_vectorized..s=14z$ ..1s#%rr$N) rrrrrrlenr%rr1r) rrc_vecrrM00dtrM_retirowicols rrrs  a% ' '' ' =1= = == = JJa0adD a0 1E 66%a.A% & && & AA aA **QqT!W C B ))A, B HHR "Ea!HD#%::agdm#> 77DA qy!!!$j 4!!!$a 4 B HHR "E qy #Bz!9"!r s(/0 NVOVOr3:O3:l_@?_@H P0P0n IIX).)R.Rj6.6vAAHCh<+\/&8<r"