
    tjP                        d dl mZ ddlmZ d dlZd dlmZ d dlm	Z	 d dl
mZmZ d dlmZ d d	lmZmZmZ d
 Zd Zd Zd Zd6dZd Zd Zd Zd Zd Zd6dZd6dZd Zd Z d Z!d Z"d Z#d Z$d6dZ%d Z&d Z'd Z(d6d Z)d! Z*d" Z+d# Z,d6d$Z-d% Z.d& Z/d6d'Z0d6d(Z1d) Z2d* Z3d+ Z4d, Z5d6d-Z6d6d.Z7d/ Z8d0 Z9d6d1Z:d2 Z;d6d3Z<d4 Z=d6d5Z>y)7    )absolute_import   )dataset_adapterN)numpy_support)vtkImageData)vtkCellDataToPointDatavtkPolyDataNormals)vtkCellDerivatives)vtkCellSizeFiltervtkCellQualityvtkMatrixMathFilterc                 4	   |st        d      t        | j                        dk(  r | j                  | j                  d   df      } | j                  d   }|dk(  r&|dk7  r!t        dt	        | j                        z         |dk(  r&|dk7  r!t        dt	        | j                        z         | j
                  j                  s| j                         } t        j                  |       }|dk(  r|j                  d       n|j                  d       |j                         }|j                  d        |j                  |j                         t        j                   j"                  | j$                  k(  rt        d	      t        j                   j&                  | j$                  k(  rr| j                  d   |j)                         k7  rt        d
      |dk(  r!|j+                         j-                  |       n|j+                         j/                  |       nt        j                   j0                  | j$                  k(  rn| j                  d   |j3                         k7  rt        d      |j                         }|j                  d        |j                  |j                         |dk(  r |j5                         j-                  |       n|j5                         j/                  |       t7               }|j9                  |       |j;                          |dk(  rJ|j+                         j-                  |j=                         j+                         j?                                nI|j+                         j/                  |j=                         j+                         jA                                |j9                  |       t        j                   j&                  | j$                  k(  rWt7               }|jC                  |jE                                |j;                          |j=                         j+                         S t        j                   j0                  | j$                  k(  r.|j;                          |j=                         j5                         S t        d	      )Nz,Need a dataset to compute _cell_derivatives.r   r   scalarsz+This function expects scalars. Input shape vectors   z+This function expects vectors. Input shape zIUnknown data association. Data should be associated with points or cells.zEThe number of points does not match the number of tuples in the arrayz>The number of does not match the number of tuples in the array)#RuntimeErrorlenshapereshapestrflags
contiguouscopyr   numpy_to_vtkSetNameNewInstance
UnRegisterCopyStructure	VTKObjectdsaArrayAssociationFIELDAssociationPOINTGetNumberOfPointsGetPointData
SetScalars
SetVectorsCELLGetNumberOfCellsGetCellDatar   SetInputDataUpdate	GetOutput
GetScalars
GetVectorsSetInputConnectionGetOutputPort)	narraydatasetattribute_typefilterncompvarraydsds2c2ps	            [/DATA/.local/lib/python3.12/site-packages/vtkmodules/numpy_interface/internal_algorithms.py_cell_derivativesr=   
   s   HII 6<<AQ34vLLOE"uz *,/,=> ? ?"uz *,/,=> ? ? <<""fkkmV''/F"FNN9$=>>)$ 
			BMM$W&&'
!!V%7%77eff
!!V%7%77
,,q/W668
8de
e
I
%r'8'C'CF'Koo**62				"	"f&8&8	8
,,q/W557
7]^
^
   "s
~~d
**+
I
%(9(D(DV(Loo**62#%s

zz| I
%
//

&
&s}}'C'C'E'P'P'R
S
//

&
&s}}'C'C'E'P'P'R
S

!!V%7%77 $%s
f2245
zz|mmo**,,				"	"f&8&8	8}} ,,.. eff    c                    | st        d      | j                         }|j                  d        |j                  | j                         t               }|j                  |       d|k(  r|j                          nd|k(  r|j                          nd|k(  r|j                          nd|k(  r|j                          nd|k(  r|j                          nd|k(  r|j                          nd|k(  r|j                          nid	|k(  r|j                          nSd
|k(  r|j                          n=d|k(  r|j!                          n'd|k(  r|j#                          nt        d|z   dz         |j%                          |j'                         j)                         j+                  d      }t-        j.                  ||       }t,        j0                  j2                  |_        |S )Nz'Need a dataset to compute _cell_qualityareaaspectaspect_gamma	conditiondiagonaljacobian	max_angleshearskew	min_anglevolumezUnknown cell quality [z].CellQuality)r   r   r   r   r   r   r,   SetQualityMeasureToAreaSetQualityMeasureToAspectRatioSetQualityMeasureToAspectGammaSetQualityMeasureToConditionSetQualityMeasureToDiagonalSetQualityMeasureToJacobianSetQualityMeasureToMaxAngleSetQualityMeasureToShearSetQualityMeasureToSkewSetQualityMeasureToMinAngleSetQualityMeasureToVolumer-   r.   r+   GetArrayr    vtkDataArrayToVTKArrayr!   r)   r#   )r4   qualityr9   r6   r8   anss         r<   _cell_qualityr[   X   s   <(QRR 
			BMM$W&&'F
	7	"V%C%C%E	7	"V%J%J%L	7	"V%J%J%L	7	"V%H%H%J	7	"V%G%G%I	7	"V%G%G%I	7	"V%G%G%I	7	"V%D%D%F	7	"V%C%C%E	7	"V%G%G%I	7	"V%E%E%G6w>tCDD
MMO++-66}EF

$
$VW
5C **//COJr>   c                    |dvrt        d|z   dz   dz         | j                  dk7  r't        |dz   dz   t        | j                        z         | j                  d   | j                  d	   k7  r't        |d
z   dz   t        | j                        z         | j                  j
                  s| j                         } | j                  d   }| j                  d   | j                  d	   z  }| j                  ||      } t               }|j                  |dd       t        j                  |       }|j                  d       |j                         j                  |       t               }|dk(  r|j!                          nA|dk(  r|j#                          n+|dk(  r|j%                          n|dk(  r|j'                          |j)                  |       |j+                          |j-                         j                         j/                  |      }t1        j2                  |      }| j4                  |_        | j6                  |_        |S )N)DeterminantInverse
EigenvalueEigenvectorzUnknown quality measure []z> Supported are [Determinant, Inverse, Eigenvalue, Eigenvector]r   z/ only works for an array of matrices(3D array).z Input shape r      z) requires an array of 2D square matrices.r   tensorsr]   r^   r_   r`   )r   ndimr   r   r   r   r   r   r   SetDimensionsr   r   r   r&   
SetTensorsr   SetOperationToDeterminantSetOperationToInverseSetOperationToEigenvalueSetOperationToEigenvectorr,   r-   r.   rW   r    rX   r#   DataSet)r3   	operationnrowsncolsr9   r8   r6   rZ   s           r<   _matrix_math_filterro   {   s   OO5i?CZ[ \ \ {{a)$UU*+-0->? @ @	aFLLO	+)$OO*+-0->? @ @ <<""fkkmV LLOELLOfll1o-E^^E5)F	BUAq!''/F
NN9OO  ( "F	m	#v'G'G'I	i	v'C'C'E	l	"v'F'F'H	m	#v'G'G'I

MMO,,.77	BF

$
$V
,C ((CO..CKJr>   c                 ,    t        j                  |       S )zCReturns the absolute values of an array of scalars/vectors/tensors.)numpyabsr3   s    r<   rr   rr          99Vr>   c                     | t         j                  u rt         j                  S t        j                  t        j                  |       |      }|S z=Returns the min value of an array of scalars/vectors/tensors.)r    	NoneArrayrq   allarrayr3   axisrZ   s      r<   rx   rx      s6    ]]
))EKK'
.CJr>   c                     t        | d      S )z0Returns the surface area of each cell in a mesh.r@   r[   r4   s    r<   r@   r@          &))r>   c                     t        | d      S )z0Returns the aspect ratio of each cell in a mesh.rA   r}   r~   s    r<   rA   rA      s    (++r>   c                     t        | d      S )z6Returns the aspect ratio gamma of each cell in a mesh.rB   r}   r~   s    r<   rB   rB      s    .11r>   c                     t        | d      S )z4Returns the condition number of each cell in a mesh.rC   r}   r~   s    r<   rC   rC          +..r>   c                    | t         j                  u s|t         j                  u rt         j                  S | j                  |j                  k7  s| j                  |j                  k7  r:t	        dt        | j                        z   dz   t        |j                        z         | j                  dk7  rI| j                  dk7  r:t	        dt        | j                        z   dz   t        |j                        z         | j                  dk(  rL| j                  d   dk7  r:t	        dt        | j                        z   dz   t        |j                        z         | j                  dk(  rL| j                  d   dk7  r:t	        d	t        | j                        z   dz   t        |j                        z         t        j                  | |      S )
zJReturn the cross product for two 3D vectors from two arrays of 3D vectors.z?Both operands must have same dimension and shape. Input shapes  and r   rb   zHCross only works for 3D vectors or an array of 3D vectors. Input shapes r   r   z.Cross only works for 3D vectors. Input shapes z9Cross only works for an array of 3D vectors.Input shapes )r    rw   rd   r   r   r   rq   cross)xys     r<   r   r      s   CMMQ#--/]]vv177agg- +-0\:<CDFI!''lS T T 	vv{qvv{ +-0\:<CDFI!''lS T T 	vv{qwwqzQ +-0\:<CDFI!''lS T T 	vv{qwwqzQ *,/L9;BCEH\R S S ;;q!r>   c                    |s| j                   }|st        d      | j                  dk7  s| j                  d   dk7  r!t        dt	        | j                        z         t               }|j                          t        | |d|      }|j                         }|j                  d       t        j                  ||      }| j                  |_        |S )z+Returns the curl of an array of 3D vectors.zNeed a dataset to compute curl.rb   r   r   z8Curl only works with an array of 3D vectors.Input shape r   	vorticity)rk   r   rd   r   r   r
   SetVectorModeToComputeVorticityr=   r0   r   r    rX   r#   r3   r4   cdresretValrZ   s         r<   curlr      s    v~~W<(IJJ{{a6<<?a/ )+.v||+<= > > 
	B&&(
FGY
;C^^F
NN;

$
$VW
5C ((COJr>   c                    |s| j                   }|st        d      | j                  dk7  s| j                  d   dk7  r!t        dt	        | j                        z         t        | |      }|j                  |j                  d   dd      }t        j                  t        j                  j                  |j                  dd      d      |j                         }	 |j                  |_        |S # t        $ r Y |S w xY w)	z1Returns the divergence of an array of 3D vectors.z$Need a dataset to compute divergencerb   r   r   z?Divergence only works with an array of 3D vectors. Input shape r   axis1axis2r~   )rk   r   rd   r   r   gradientr   r    VTKArrayrq   addreducerD   r#   AttributeError)r3   r4   gas       r<   
divergencer      s    v~~W<(NOO{{a6<<?a/ *,/,=> ? ? 	!A			!''!*a#AIIQZZaqZ91=qyy	RA H 4H  s   C. .	C;:C;c                     t        | d      S ):Returns the determinant of an array of 2D square matrices.r]   ro   rs   s    r<   detr         v}55r>   c                     t        |       S )r   )r   rs   s    r<   determinantr         v;r>   c                     t        | d      S )z6Returns the diagonal length of each cell in a dataset.rD   r}   r~   s    r<   rD   rD         *--r>   c                    | t         j                  u s|t         j                  u rt         j                  S | j                  d   |j                  d   k7  r:t        dt	        | j                        z   dz   t	        |j                        z         | |z  }t        j
                  t        j                  j                  |d            }t        |d      r|j                  |_
        | j                  |j                  k(  r| j                  |_        |S )zOReturns the dot product of two scalars/vectors of two array of scalars/vectors.r   zDDot product only works with vectors of same dimension. Input shapes r   r#   )r    rw   r   r   r   r   rq   r   r   hasattrr#   rk   )a1a2mvas       r<   dotr     s    	S]]bCMM1]]	xx{bhhqk! *,/M:<CDFI"((mT U U
2A	eii&&q!,	-Bq- }}bn	zzRZZrzz"*Ir>   c                     t        | d      S )z9Returns the eigenvalue of an array of 2D square matrices.r_   r   rs   s    r<   
eigenvaluer   '  s    v|44r>   c                     t        | d      S )z:Returns the eigenvector of an array of 2D square matrices.r`   r   rs   s    r<   eigenvectorr   +  r   r>   c                 |   |s| j                   }|st        d      	 | j                  d   }|dk7  r&|dk7  r!t        dt	        | j                        z         t               }|dk(  rd}nd}t        | |||      }|dk(  r|j                         }n|j                         }	 | j                         r#|j                  d| j                         z          n|j                  d       t        j                  ||      }| j                  |_        |S # t        $ r d}Y w xY w# t        $ r |j                  d       Y Vw xY w)	z4Returns the gradient of an array of scalars/vectors.z"Need a dataset to compute gradientr   r   zUGradient only works with scalars (1 component) and vectors (3 component) Input shape r   r   zgradient of r   )rk   r   r   
IndexErrorr   r
   r=   r0   
GetTensorsGetNamer   r   r    rX   r#   )r3   r4   r7   r   r5   r   r   rZ   s           r<   r   r   /  s.   fnnG,'KLLll1oe zeqj *,/,=> ? ? 
	BzYN%>
FG^R
@CzS^^-FNN$67>>fnn^fnn>N-NO~~j) 
$
$VW
5C ((COJ5  e$ 6FNN:66s$   D  AD DDD;:D;c                     t        | d      S )z3Returns the inverse an array of 2D square matrices.r^   r   rs   s    r<   invr   R  s    vy11r>   c                     t        |       S )z6Returns the inverse of an array of 2D square matrices.)r   rs   s    r<   inverser   V  r   r>   c                     t        | d      S )z7Returns the jacobian of an array of 2D square matrices.rE   r}   r~   s    r<   rE   rE   Z  r   r>   c                 f    |s| j                   }|st        d      t        | |      }t        |      S )z,Returns the jacobian of an array of scalars.z#Need a dataset to compute laplacian)rk   r   r   r   )r3   r4   rZ   s      r<   	laplacianr   ^  s1    v~~W<(MNN
67
#Cc?r>   c                 ,    t        j                  |       S zEReturns the natural logarithm of an array of scalars/vectors/tensors.)rq   logrs   s    r<   lnr   e  rt   r>   c                     t        |       S r   )r   rs   s    r<   r   r   i  s    f:r>   c                 ,    t        j                  |       S )zEReturns the base 10 logarithm of an array of scalars/vectors/tensors.)rq   log10rs   s    r<   r   r   m  s    ;;vr>   c                 v    | t         j                  u rt         j                  S t        j                  | |      }|S )zAReturns the maximum value of an array of scalars/vectors/tensors.)r    rw   rq   maxrz   s      r<   r   r   q  -    ]]
))FD
!CJr>   c                     t        | d      S )z4Returns the maximum angle of each cell in a dataset.rF   r}   r~   s    r<   rF   rF   y  r   r>   c                 @    t        j                  t        | |             S )z5Returns the magnigude of an array of scalars/vectors.)rq   sqrtr   r   s    r<   magr   }  s    ::c!Qi  r>   c                     | t         j                  u rt         j                  S t        j                  t        j                  |       |      }|S z>Returns the mean value of an array of scalars/vectors/tensors.)r    rw   rq   meanry   rz   s      r<   r   r     s6    ]]
**U[[($
/CJr>   c                 v    | t         j                  u rt         j                  S t        j                  | |      }|S rv   )r    rw   rq   minrz   s      r<   r   r     r   r>   c                     t        | d      S )z4Returns the minimum angle of each cell in a dataset.rI   r}   r~   s    r<   rI   rI     r   r>   c                 Z    | t        |       j                  | j                  d   df      z  S )z=Returns the normalized values of an array of scalars/vectors.r   r   )r   r   r   r   s    r<   normr     s&    SV^^QWWQZO,,,r>   c                     t        | d      S )z,Returns the shear of each cell in a dataset.rG   r}   r~   s    r<   rG   rG     s    '**r>   c                     t        | d      S )z+Returns the skew of each cell in a dataset.rH   r}   r~   s    r<   rH   rH     r   r>   c                    |s| j                   }|st        d      d| j                  k7  sd| j                  d   k7  r!t        dt	        | j                        z         t               }|j                          t        | |d|      }|j                         }|j                  d       t        j                  ||      }| j                  |_        |S )z-Returns the strain of an array of 3D vectors.z Need a dataset to compute strainrb   r   r   z9strain only works with an array of 3D vectorsInput shape r   strain)rk   r   rd   r   r   r
   SetTensorModeToComputeStrainr=   r   r   r    rX   r#   r   s         r<   r   r     s    v~~W<(JKKFKK1Q/ )+.v||+<= > > 
	B##%
FGY
;C^^F
NN8

$
$VW
5C ((COJr>   c                 r    | t         j                  u rt         j                  S t        j                  | |      S rv   )r    rw   rq   sumr3   r{   s     r<   r   r     )    ]]99VT""r>   c                    | st        d      | j                         }|j                  d       |j                  | j                         t               }|j                  |       |j                          |j                          |j                  d       |j                          |j                          |j                          |j                          |j                          |j                          |j!                         j#                         j%                         }t'        j(                  ||       }t&        j*                  j,                  |_        |S )z5Returns the surface normal of each cell in a dataset.z(Need a dataset to compute surface_normalN   )r   r   r   r   r   r	   r,   ComputeCellNormalsOnComputePointNormalsOffSetFeatureAngleSplittingOffConsistencyOffAutoOrientNormalsOffFlipNormalsOffNonManifoldTraversalOffr-   r.   r+   
GetNormalsr    rX   r!   r)   r#   r4   r9   r6   r8   rZ   s        r<   surface_normalr     s   <(RSS				BMM$W&&'!F

!
!!#
3


!

""$
MMO++-88:F

$
$VW
5C **//COJr>   c                 `    d}d}| j                   dkD  rd}d}t        j                  | ||      S )z4Returns the trace of an array of 2D square matrices.r   r   rb   r   )rd   rq   trace)r3   ax1ax2s      r<   r   r     s4    
C
C{{Qss;;vS44r>   c                 r    | t         j                  u rt         j                  S t        j                  | |      S r   )r    rw   rq   varr   s     r<   r   r     r   r>   c                 4   | st        d      | j                         }|j                  d       |j                  | j                         t               }|j                  |       |j                          |j                          |j                          |j                          |j                         j                         j                  d      }|j                  d       t        j                   ||       }t        j"                  j$                  |_        |S )z-Returns the volume of each cell in a dataset.z Need a dataset to compute volumeNVolumerK   )r   r   r   r   r   r   r,   ComputeVertexCountOffComputeLengthOffComputeAreaOffr-   r.   r+   rW   r   r    rX   r!   r)   r#   r   s        r<   rJ   rJ     s     <(JKK 
			BMM$W&&' F

  "


MMO++-66x@F
NN=!

$
$VW
5C **//COJr>   c                     t        | |      S )z5Returns the vorticity/curl of an array of 3D vectors.)r   )r3   r4   s     r<   r   r     s      r>   c                    | st        d      | j                         }|j                  d       |j                  | j                         t               }|j                  |       |j                          |j                          |j                  d       |j                          |j                          |j                          |j                          |j                          |j                          |j!                         j#                         j%                         }t'        j(                  ||       }t&        j*                  j,                  |_        |S )z5Returns the vertex normal of each point in a dataset.z'Need a dataset to compute vertex_normalNr   )r   r   r   r   r   r	   r,   ComputeCellNormalsOffComputePointNormalsOnr   r   r   r   r   r   r-   r.   r&   r   r    rX   r!   r$   r#   r   s        r<   vertex_normalr     s   <(QRR				BMM$W&&'!F

  "
  "
3


!

""$
MMO,,.99;F

$
$VW
5C **00COJr>   c                    | t         j                  u s$|t         j                  u s|t         j                  u rt         j                  S t        | j                        dk7  s2t        |j                        dk7  s|#t        |j                        dk7  rt	        d      |t        j                  | j                        }t        j                  | ||g      j                         j                  t         j                        }	 | j                  |_        	 | j                  |_        |S # t        $ r Y w xY w# t        $ r Y |S w xY w)Nr   zCan only merge 1D arrays)r    rw   r   r   
ValueErrorrq   zerosvstack	transposeviewr   rk   r   r#   )axayazvs       r<   make_vectorr  *  s    	S]]bCMM1R3==5H]]
288}S]a/BNs288}XYGY344	z[["b"b\",,.33CLLAA JJ	 H	 4 4H  s$   D& D5 &	D21D25	EE)N)?
__future__r    r   r    rq   vtkmodules.utilr   vtkmodules.vtkCommonDataModelr   vtkmodules.vtkFiltersCorer   r	   vtkmodules.vtkFiltersGeneralr
   vtkmodules.vtkFiltersVerdictr   r   r   r=   r[   ro   rr   rx   r@   rA   rB   rC   r   r   r   r   r   rD   r   r   r   r   r   r   rE   r   r   r   r   r   rF   r   r   r   rI   r   rG   rH   r   r   r   r   r   rJ   r   r   r   r>   r<   <module>r     s   & $  ) 6 P ; _ _Lg\!F/d*,2/.2(6.56!F2./!/-+*2#<5#6!<r>   