. Transform documentation master file
Transform module performs simple transformations of meshes. It works on arrays (as defined in Converter documentation) or on CGNS/Python trees (pyTrees), if they provide grid coordinates. In the pyTree version, flow solution nodes and boundary conditions and grid connectivity are preserved if possible. In particular, splitting a mesh does not maintain the grid connectivity.
This module is part of Cassiopee, a free opensource pre and postprocessor for CFD simulations.
To use the module with the Converter.array interface:
import Transform as T
To use the module with the CGNS/Python interface:
import Transform.PyTree as T
– Basic operations
oneovern(a, N[, add])  Take one over N points from mesh. 
reorder(a, order)  Reorder the numerotation of mesh. 
reorderAll(arrays[, dir])  Orientate normals of all surface blocks consistently in one direction (1) or the opposite (1). 
makeCartesianXYZ(a)  Reorder a Cartesian mesh in order to get i,j,k aligned with X,Y,Z. 
makeDirect(a)  Reorder a structured mesh to make it direct. 
addkplane(a[, N])  Add N kplane(s) to a mesh. 
collapse(a)  Collapse the smallest edge of each element for TRI arrays. Return a BAR. 
patch(a1, a2[, position, nodes])  Patch mesh2 defined by a2 in mesh1 defined by a1 at position (i,j,k). 
– Mesh positioning
rotate(a, center, arg1[, arg2, vectors])  Rotate a grid. 
translate(a, transvect)  Translate a grid. 
– Mesh transformation
cart2Cyl(a, 0, 0[, center, axis])  Transform a mesh defined in Cartesian coordinates into cylindrical coordinates. 
homothety(a, center, alpha)  Make for a mesh defined by an array an homothety of center Xc and 
contract(a, center, dir1, dir2, alpha)  Contract a mesh around a plane defined by (center, dir1, dir2) and of factor alpha. 
scale(a[, factor])  Scale a mesh following factor (constant) or (f1,f2,f3) following dir. 
symetrize(a, point, vector1, vector2)  Make a symetry of mesh from plane passing by point and of director vector: vector1 and vector2. 
perturbate(a, radius[, dim])  Perturbate a mesh randomly of radius 
smooth(a, 0[, eps, niter, type, ...])  Smooth a mesh with a Laplacian. 
dual(array[, extraPoints])  Returns the dual mesh of a conformal mesh. 
breakElements(a)  Break an array (in general NGON) in a set of arrays 
– Mesh splitting and merging
subzone(array, minIndex[, maxIndex, type])  Take a subzone of mesh. 
join(array[, array2, arrayc, arrayc2, tol])  Join two arrays in one or join a list of arrays in one. 
merge(A[, Ac, sizeMax, dir, tol, alphaRef])  Merge a list of matching structured grids. 
mergeCart(A[, sizeMax, tol])  Merge a list of Cartesian zones using the method of weakest descent. 
splitNParts(arrays, N, 2[, multigrid, dirs])  
splitSize(array, 2[, N, multigrid, dirs, ...])  Split a block until it has less than N points. 
splitCurvatureAngle(array, sensibility)  Split a line following curvature angle. 
splitCurvatureRadius(a[, Rs])  Return the indices of the array where the curvature radius is low. 
splitConnexity(a)  Split array into connex zones. 
splitMultiplePts(A[, dim])  Split any zone of A if it is connected to several blocks at a given border. 
splitSharpEdges(array[, alphaRef])  Split array into smooth zones (angles between elements are less than 
splitTBranches(array[, tol])  Split a BAR into a set of BARS at vertices where T branches exist. 
splitManifold(array)  Split an unstructured mesh (only TRI or BAR currently) into several manifold pieces. 
splitBAR(array, N)  Split BAR at index N (start 0). 
splitTRI(array, idxList)  Split a TRI into several TRIs delimited by the input poly line defined by the lists of indices idxList. 
– Mesh deformation
deform(a[, vector])  Deform surface by moving surface of the vector dx, dy, dz. 
deformNormals(array, alpha[, niter])  Deform a a surface of alpha times the surface normals. 
deformPoint(a, xyz, dxdydz, depth, width)  Deform mesh by moving point (x,y,z) of a vector (dx, dy, dz). 
deformMesh(a, surfDelta[, beta, type])  Deform a mesh wrt surfDelta defining surface grids and deformation vector on it. 
– Mesh projections
projectAllDirs(arrays, surfaces[, vect, ...])  Project points defined in arrays to surfaces according to the direction provided by vect. 
projectDir(surfaces, arrays, dir[, smooth, ...])  Project surfaces onto surface arrays following dir. 
projectOrtho(surfaces, arrays)  Project a list of zones surfaces onto surface arrays following normals. 
projectOrthoSmooth(surfaces, arrays[, niter])  Project a list of zones surfaces onto surface arrays following normals. 
projectRay(surfaces, arrays, P)  Project surfaces onto surface arrays using rays starting from P. 
Extract every Ni,Nj,Nk point in the three directions of a structured mesh a.
Exists also as an inplace version (_oneovern) which modifies a and returns None.
Parameters: 


Returns:  a coarsened structured mesh 
Return type:  Identical to a 
Example of use:
#  oneovern (array) 
import Transform as T
import Converter as C
import Generator as G
a = G.cart((0,0,0), (1,1,1), (10,10,1))
a2 = T.oneovern(a, (2,2,2))
C.convertArrays2File([a2], "out.plt")
#  oneovern (pyTree) 
import Transform.PyTree as T
import Converter.PyTree as C
import Generator.PyTree as G
a = G.cart((0,0,0), (1,1,1), (10,10,1))
a2 = T.oneovern(a, (2,2,1)); a2[0] = 'cart2'
C.convertPyTree2File([a,a2], "out.cgns")
For a structured grid, change the (i,j,k) ordering of a. To reorder a mesh (i,j,k) into (i2,j2,k2), the transformation can be achieved through a matrix M, filled with a single nonzero value per line and column (equal to 1 or 1). dest=(desti,destj,destk) means: M[abs(desti),1]=sign(desti); M[abs(destj),2]=sign(destj); M[abs(destk),3]=sign(destk)
For an unstructured 2D grid (TRI, QUAD, 2D NGON), order the normals such that they are all oriented towards the same direction.
Exists also as an inplace version (_reorder) which modifies a and returns None.
Parameters: 


Returns:  a reoriented mesh 
Return type:  an array or a zone 
Example of use:
#  reorder (array) 
import Generator as G
import Transform as T
import Converter as C
# Structured
a = G.cart((0,0,0),(1,1,1),(5,7,9))
a = T.reorder(a, (3,2,1))
C.convertArrays2File([a], 'out1.plt')
# Unstructured
a = G.cartTetra((0,0,0),(1,1,1),(3,3,1))
c = a[2]; c[1,0] = 5; c[2,0] = 2
a = T.reorder(a, (1,))
C.convertArrays2File([a], 'out2.plt')
#  reorder (pyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (8,9,20))
a = T.reorder(a, (2,1,3))
C.convertPyTree2File(a, "out.cgns")
Order a set of surface grids a in the same direction. All the grids in a must be of same nature (structured or unstructured). Orientation of the first grid in the list is used to reorder the other grids. If dir=1, the orientation is the opposite direction of the normals of the first grid.
In case of unstructured grids, reorientation is guaranteed to be outward (by default) if they represent a closed volume.
Exists also as an inplace version (_reorderAll) which modifies a and returns None.
Parameters: 


Returns:  a reoriented mesh 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  reorderAll (array) 
import Converter as C
import Generator as G
import Transform as T
ni = 30; nj = 40
m1 = G.cart((0,0,0), (10./(ni1),10./(nj1),1), (ni,nj,1))
m2 = T.rotate(m1, (0.2,0.2,0.), (0.,0.,1.), 15.)
m2 = T.reorder(m2,(1,2,3))
a = [m1,m2]
a = T.reorderAll(a,1)
C.convertArrays2File(a, "out.plt")
#  reorderAll (pyTree) 
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
ni = 30; nj = 40; nk = 1
m1 = G.cart((0,0,0), (10./(ni1),10./(nj1),1), (ni,nj,nk)); m1[0]='cart1'
m2 = T.rotate(m1, (0.2,0.2,0.), (0.,0.,1.), 15.)
m2 = T.reorder(m2,(1,2,3)); m2[0]='cart2'
t = C.newPyTree(['Base',2,[m1,m2]])
t = T.reorderAll(t, 1)
C.convertPyTree2File(t, "out.cgns")
Align a structured Cartesian mesh in order to get i,j,k aligned with X,Y,Z respectively. Exists also as an inplace version (_makeCartesianXYZ) which modifies a and returns None.
Parameters:  a (array or zone) – Cartesian mesh with (i,j,k) not aligned with (X,Y,Z) 

Returns:  a Cartesian mesh such that direction i is aligned with (0X) etc 
Return type:  array or zone 
Example of use:
#  makeCartesian(array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart((0.,0.,0.),(1.,1.,1.),(11,12,13))
a = T.reorder(a, (3,2,1))
a = T.makeCartesianXYZ(a)
C.convertArrays2File([a],'out.plt')
#  makeCartesian(pyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0.,0.,0.),(1.,1.,1.),(11,12,13))
a = T.reorder(a, (3,2,1))
a = T.makeCartesianXYZ(a)
C.convertPyTree2File(a,'out.cgns')
Reorder an indirect structured mesh to get a direct mesh. Exists also as an inplace version (_makeDirect) which modifies a and returns None.
Parameters:  a (array or zone) – structured mesh 

Returns:  a direct structured mesh 
Return type:  array or zone 
Example of use:
#  makeDirect (array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart((0.,0.,0.),(1.,1.,1.),(10,10,10))
a = T.reorder(a, (1,2,3)) # indirect now
a = T.makeDirect(a)
C.convertArrays2File([a], 'out.plt')
#  makeDirect (pyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0.,0.,0.),(1.,1.,1.),(10,10,10))
a = T.reorder(a, (1,2,3)) # indirect now
a = T.makeDirect(a)
C.convertPyTree2File(a, 'out.cgns')
Add one or more planes at constant heights z0+1, ...,z0+N. Exists also as an inplace version (_addkplane) which modifies a and returns None.
Parameters: 


Returns:  a structured mesh 
Return type:  array or zone 
Example of use:
#  addkplane (array) 
import Geom as D
import Transform as T
import Converter as C
a = D.naca(12., 501)
a = T.addkplane(a)
C.convertArrays2File([a], "out.plt")
#  addkplane (pyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0.,0.,0.),(0.1,0.1,1.),(10,10,2))
a = T.addkplane(a)
C.convertPyTree2File(a, 'out.cgns')
Collapse and extract smallest edges of a triangular mesh Exists also as an inplace version (_collapse) which modifies a and returns None.
Parameters:  a (array or zone) – triangular mesh 

Returns:  a set of edges as BAR elements 
Return type:  an array or a zone 
Example of use:
#  collapse (array) 
import Converter as C
import Generator as G
import Transform as T
hi = 0.1; hj = 0.01; hk = 1.
ni = 20; nj = 2; nk = 1
a = G.cartTetra((0.,0.,0.),(hi,hj,hk),(ni,nj,nk))
b = T.collapse(a)
C.convertArrays2File([a,b], "out.plt")
#  collapse (pyTree) 
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
hi = 0.1; hj = 0.01; hk = 1.
ni = 20; nj = 2; nk = 1
a = G.cartTetra((0.,0.,0.),(hi,hj,hk),(ni,nj,nk))
b = T.collapse(a)
C.convertPyTree2File(b, "out.cgns")
For a structured mesh a, patch (replace) a structured mesh b from starting point position=(i,j,k) of a. For an unstructured mesh a, patch an unstructured mesh (of same type) by replacing the nodes of indices nodes.
Exists also as an inplace version (_patch) which modifies a and returns None.
Parameters: 


Returns:  a modified zone 
Return type:  an array or a zone 
Example of use:
#  patch (array) 
import Transform as T
import Generator as G
import Converter as C
import numpy
c1 = G.cart((0,0,0), (0.01,0.01,1), (201,101,1))
c2 = G.cart((0,0,0), (0.01,0.01,1), (51,81,1))
c2 = T.rotate(c2, (0,0,0),(0,0,1),0.2)
c3 = G.cart((0.0,1.,0), (0.01,0.01,1), (101,1,1))
c3 = T.rotate(c3, (0,0,0),(0,0,1),0.3)
# patch a region
a = T.patch(c1, c2,(1,1,1))
# patch some nodes
nodes = numpy.arange(20100, 20201, dtype=numpy.int32)
b = T.patch(c1, c3, nodes=nodes)
C.convertArrays2File([a,b], 'out.plt')
#  patch (pyTree) 
import Transform.PyTree as T
import Generator.PyTree as G
import Converter.PyTree as C
c1 = G.cart((0,0,0), (0.01,0.01,1), (201,101,1))
c2 = G.cart((0,0,0), (0.01,0.01,1), (51,81,1))
a = T.patch(c1, c2,(1,1,1))
C.convertPyTree2File(a, 'out.cgns')
Rotate a mesh. Rotation can be also applied on some vector fields (e.g. velocity and momentum). If the vector field is located at cell centers, then each vector component name must be prefixed by ‘centers:’.
Exists also as an inplace version (_rotate) which modifies a and returns None.
Rotation can be defined by:
Parameters: 


Returns:  mesh after rotation 
Return type:  array or zone 
Example of use:
#  rotate (array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart( (0,0,0), (1,1,1), (10,10,1))
# Rotate with an axis and an angle
b = T.rotate(a, (0.,0.,0.), (0.,0.,1.), 30.)
# Rotate with axis transformations
c = T.rotate(a, (0.,0.,0.), ((1.,0.,0.),(0,1,0),(0,0,1)),
((1,1,0), (1,1,0), (0,0,1)) )
# Rotate with three angles
d = T.rotate(a, (0.,0.,0.), (90.,0.,0.))
C.convertArrays2File([a,d], 'out.plt')
#  rotate (PyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (10,10,2))
# Rotate with an axis and an angle
b = T.rotate(a, (0.,0.,0.), (0.,0.,1.), 30.); b[0] = 'cartRot1'
# Rotate with two axis
c = T.rotate(a, (0.,0.,0.), ((1.,0.,0.),(0,1,0),(0,0,1)),
((1,1,0), (1,1,0), (0,0,1)) ); c[0] = 'cartRot2'
# Rotate with three angles
c = T.rotate(a, (0.,0.,0.), (0,0,90)); c[0] = 'cartRot3'
C.convertPyTree2File([a,b,c], 'out.cgns')
Translate a mesh of vector T=(tx,ty,tz).
Exists also as an inplace version (_translate) which modifies a and returns None.
Parameters: 


Returns:  mesh after translation 
Return type:  array or zone 
Example of use:
#  translate (array) 
import Transform as T
import Generator as G
import Converter as C
a = G.cart( (0,0,0), (1,1,1), (10,10,1))
b = T.translate(a, (1.,0.,0.))
C.convertArrays2File([a,b], 'out.plt')
#  translate (pyTree) 
import Transform.PyTree as T
import Generator.PyTree as G
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (10,10,3))
T._translate(a, (10.,0.,0.))
C.convertPyTree2File(a, 'out.cgns')
Convert a mesh in Cartesian coordinates into a mesh in cylindrical coordinates. One of the Cartesian axes, defined by parameter AXIS, must be the revolution axis of the cylindrical frame. AXIS can be (0,0,1), (1,0,0) or (0,1,0).
Exists also as an inplace version (_cart2Cyl) which modifies a and returns None.
Parameters: 


Returns:  mesh with coordinates in the cylindrical frame 
Return type:  array or zone 
Example of use:
#  cart2Cyl (array) 
import Transform as T
import Generator as G
import Converter as C
a = G.cylinder((0.,0.,0.), 0.5, 1., 0., 360, 1., (360,20,10))
a = T.cart2Cyl(a, (0.,0.,0.),(0,0,1))
C.convertArrays2File(a, 'out.plt')
#  cart2Cyl (pyTree) 
import Transform.PyTree as T
import Generator.PyTree as G
import Converter.PyTree as C
a = G.cylinder((0.,0.,0.), 0.5, 1., 0., 360., 1., (360,20,10))
T._cart2Cyl(a, (0.,0.,0.),(0,0,1))
C.convertPyTree2File(a, 'out.cgns')
Apply an homothety of center C and a factor alpha to a mesh a.
Exists also as an inplace version (_homothety) which modifies a and returns None.
Parameters: 


Returns:  mesh after translation 
Return type:  array or zone 
Example of use:
#  homothety (array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart((0,0,0), (1,1,1), (10,10,1))
b = T.homothety(a, (0.,0.,0.), 2.)
C.convertArrays2File([a,b], 'out.plt')
#  homothety (PyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (10,10,10))
b = T.homothety(a, (0.,0.,0.), 2.); b[0] = 'cart2'
C.convertPyTree2File([a,b], "out.cgns")
Make a contraction of factor alpha of a mesh with respect to a plane defined by a point C and vectors dir1 and dir2.
Exists also as an inplace version (_contract) which modifies a and returns None.
Parameters: 


Returns:  mesh after contraction 
Return type:  array or zone 
Example of use:
#  contract (array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart( (0,0,0), (1,1,1), (10,10,10))
b = T.contract(a, (0.,0.,0.), (1,0,0), (0,1,0), 0.1)
C.convertArrays2File([a,b], 'out.plt')
#  contract (pytree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (10,10,10))
b = T.contract(a, (0.,0.,0.), (1,0,0), (0,1,0), 0.1); b[0]='cart2'
C.convertPyTree2File([a,b], 'out.cgns')
Scale a mesh of factor factor.
Exists also as an inplace version (_scale) which modifies a and returns None.
Parameters: 


Returns:  mesh after scaling 
Return type:  array or zone 
Example of use:
#  scale (array) 
import Transform as T
import Generator as G
import Converter as C
a = G.cart((0,0,0), (1,1,1), (10,10,10))
# scale in all directions
a = T.scale(a, factor=0.1)
# scale with different factors following directions
a = T.scale(a, factor=(0.1,0.2,0.3))
C.convertArrays2File(a, 'out.plt')
#  scale (pyTree) 
import Transform.PyTree as T
import Generator.PyTree as G
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (10,10,10))
# scale in all directions
T._scale(a, factor=0.1)
# scale with different factors following directions
T._scale(a, factor=(0.1,0.2,0.3))
C.convertPyTree2File(a, 'out.cgns')
Symmetrize a mesh with respect to a plane defined by point P and vectors vector1 and vector2.
Exists also as an inplace version (_symetrize) which modifies a and returns None.
Parameters: 


Returns:  mesh after symmetrization 
Return type:  array or zone 
Example of use:
#  symetrize (array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart((0,0,0), (1,1,1), (10,10,1))
b = T.symetrize(a, (0.,0.,0.), (1,0,0), (0,0,1))
C.convertArrays2File([a,b], "out.plt")
#  symetrize (PyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (10,10,2))
b = T.symetrize(a, (0.,0.,0.), (1,0,0), (0,0,1)); b[0]='cart2'
C.convertPyTree2File([a,b], "out.cgns")
Perturbate randomly a mesh a with given radius. If dim=2, Z coordinates are fixed. If dim=1, only the X coordinates are modified.
Exists also as an inplace version (_perturbate) which modifies a and returns None.
Parameters: 


Returns:  mesh after perturbation 
Return type:  array or zone 
Example of use:
#  perturbate (array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart((0,0,0), (1,1,1), (10,10,1))
a = T.perturbate(a, 0.1)
C.convertArrays2File([a], "out.plt")
#  perturbate (PyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (10,10,2))
b = T.perturbate(a, 0.1); b[0]='cart2'
C.convertPyTree2File([a,b], "out.cgns")
Perform a Laplacian smoothing on a set of structured grids or an unstructured mesh (‘QUAD’, ‘TRI’) with a weight eps, and niter smoothing iterations. Type=0 means isotropic Laplacian, type=1 means scaled Laplacian, type=2 means taubin smoothing. Constraints can be defined in order to avoid smoothing of some points (for instance the exterior faces of a):
Exists also as an inplace version (_smooth) which modifies a and returns None.
Parameters: 


Returns:  mesh after smoothing 
Return type:  array or zone 
Example of use:
#  smooth (array) 
import Transform as T
import Converter as C
import Geom as D
a = D.sphere6((0,0,0), 1, N=20)
b = T.smooth(a, eps=0.5, niter=20)
C.convertArrays2File(a+b, "out.plt")
#  smooth (pyTree) 
import Transform.PyTree as T
import Geom.PyTree as D
import Converter.PyTree as C
a = D.sphere6((0,0,0), 1, N=20)
b = T.smooth(a, eps=0.5, niter=20)
C.convertPyTree2File(b, "out.cgns")
Return the dual of a mesh a. If extraPoints=1, external face centers are added.
Exists also as an inplace version (_dual) which modifies a and returns None.
Parameters: 


Returns:  dual mesh 
Return type:  array or zone 
Example of use:
import Converter as C
import Generator as G
import Transform as T
import Geom as D
ni = 5; nj = 5; nk = 1
a = G.cart((0,0,0),(1,1,1),(ni,nj,nk))
a = C.convertArray2NGon(a); a = G.close(a)
res = T.dual(a)
C.convertArrays2File([res],'out.tp')
#  dual (pyTree)
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
import Geom.PyTree as D
ni = 5; nj = 5
a = G.cart((0,0,0),(1,1,1),(ni,nj,1))
a = C.convertArray2NGon(a); a = G.close(a)
res = T.dual(a)
C.convertPyTree2File(res, 'out.cgns')
Break a NGON mesh into a set of grids, each of them being a basic element grid (with a single connectivity)
Parameters:  a (array or zone) – NGON mesh 

Returns:  list of grids of basic elements 
Return type:  [list of arrays or list of zones] 
Example of use:
#  breakElements (array) 
import Converter as C
import Generator as G
import Transform as T
a = G.cartTetra((0,0,0),(1,1,1),(3,3,2))
a = C.convertArray2NGon(a)
a = G.close(a)
b = G.cartNGon((2,0,0),(1,1,1),(3,2,2))
res = T.join(a,b)
res = T.breakElements(res)
C.convertArrays2File(res, 'out.plt')
#  breakElements (pyTree) 
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
a = G.cartTetra((0,0,0),(1,1,1),(3,3,2))
a = C.convertArray2NGon(a)
a = G.close(a)
b = G.cartNGon((2,0,0),(1,1,1),(3,3,1))
res = T.join(a,b)
res = T.breakElements(res)
C.convertPyTree2File(res, 'out.cgns')
Extract a subzone.
Extract a subzone of a structured mesh a, where min and max ranges must be specified. Negative indices can be used (as in Python): 1 means max index:
b = T.subzone(a, (imin,jmin,kmin), (imax,jmax,kmax))
Extract a subzone of an unstructured mesh a, where the vertex list of the subzone must be specified (indices start at 1):
b = T.subzone(a, [1,2,...])
Extract a subzone of an unstructured mesh providing the indices of elements (index starts at 0):
b = T.subzone(a, [0,1,...], type='elements')
Extract a subzone of an unstructured array providing the indices of faces (for unstructured zones with basic elements: indFace=indElt*numberOfFaces+noFace, for NGON zones: use the natural face indexing, starting from 1):
b = T.subzone(a, [1,2,...], type='faces')
Parameters: 


Returns:  subzoned mesh 
Return type:  identical to a 
Example of use:
#  subzone (array) 
import Converter as C
import Transform as T
import Generator as G
# Structure
a = G.cart((0,0,0), (1,1,1), (10,20,10))
a = T.subzone(a, (3,3,3), (7,8,5))
# Structure avec indices negatif
e = G.cart((0,0,0), (1,1,1), (10,20,10))
e = T.subzone(e, (1,1,1), (1,1,2)) # imax,jmax,kmax1
# Non structure. Indices de noeuds > retourne elts
b = G.cartTetra((0,0,0), (1,1,1), (2,2,2))
b = T.subzone(b, [2,6,8,5])
# Non structure. Indices d'elements > Retourne elts
# Les indices d'elements commencent a 0
c = G.cartTetra((0,0,0), (1,1,1), (5,5,5))
c = T.subzone(c, [0,1], type='elements')
# Non structure. Indices de faces:
# Pour les maillages BAR, TRI, TETRA... indFace=indElt*nbreFaces+noFace
# les noFace commence a 1
# Pour les NGONS... indices des faces
# > Retourne les faces
d = G.cartTetra((0,0,0), (1,1,1), (2,2,2))
d = T.subzone(d, [1,2,3], type='faces')
C.convertArrays2File([a,b,c,d,e], 'out.plt')
#  subzone (pyTree) 
import Converter.PyTree as C
import Transform.PyTree as T
import Generator.PyTree as G
a = G.cart((0,0,0), (1,1,1), (10,20,1))
a = T.subzone(a, (3,3,1), (7,8,1))
C.convertPyTree2File(a, 'out.cgns')
Join two zones in one (if possible) or join a list of zones in one zone (if possible). For the pyTree version, boundary conditions are maintained for structured grids only.
Parameters:  a ([array, list of arrays] or [zone, list of zones, base, pyTree]) – Input data 

Returns:  unique joined zone 
Return type:  array or zone 
Example of use:
#  join (array) 
import Geom as D
import Transform as T
import Converter as C
import Generator as G
a1 = G.cartTetra((0.,0.,0.), (1.,1.,1), (11,11,1))
a2 = G.cartTetra((10.,0.,0.), (1.,1.,1), (10,10,1))
a = T.join(a1, a2)
C.convertArrays2File([a], 'out.plt')
#  join (pyTree) 
import Geom.PyTree as D
import Transform.PyTree as T
import Converter.PyTree as C
a1 = D.naca(12., 5001)
a2 = D.line((1.,0.,0.),(20.,0.,0.),5001)
a = T.join(a1, a2)
C.convertPyTree2File(a, "out.cgns")
Join a set of zones such that a minimum number of zones is obtained at the end. Parameter sizeMax defines the maximum size of merged grids. dir is the constraint direction along which the merging is prefered. Default value is 0 (no prefered direction), 1 for i, 2 for j, 3 for k. alphaRef can be used for surface grids and avoids merging adjacent zones sharing an angle deviating of alphaRef to 180:
For the pyTree version, boundary conditions are maintained for structured grids only.
Parameters: 


Returns:  list of merged grids 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  merge (array) 
import Converter as C
import Generator as G
import Transform as T
import Geom as D
def f(t,u):
x = t+u; y = t*t+1+u*u; z = u
return (x,y,z)
a = D.surface(f)
b = T.splitSize(a, 100)
b = T.merge(b)
C.convertArrays2File(b, "out.plt")
#  merge (pyTree) 
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
import Connector.PyTree as X
import Geom.PyTree as D
def f(t,u):
x = t+u
y = t*t+1+u*u
z = u
return (x,y,z)
a = D.surface(f)
b = T.splitSize(a, 100)
b = X.connectMatch(b, dim=2)
t = C.newPyTree(['Surface']); t[2][1][2] += b
b = T.merge(t)
t[2][1][2] = b
C.convertPyTree2File(t, "out.cgns")
Merge a set of Cartesian grids. This function is similar to the function Transform.merge but is optimized for Cartesian grids.
Parameters: 


Returns:  list of merged Cartesian grids 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  mergeCart (array) 
import Converter as C
import Generator as G
import Transform as T
dh = 0.1; n = 11
A = []
a1 = G.cart((0.,0.,0.),(dh,dh,dh),(n,n,n)); A.append(a1)
a2 = G.cart((1.,0.,0.),(dh,dh,dh),(n,n,n)); A.append(a2)
a3 = G.cart((1.,1.,0.),(dh,dh,dh),(n,n,n)); A.append(a3)
a4 = G.cart((0.,1.,0.),(dh,dh,dh),(n,n,n)); A.append(a4)
A[0] = T.oneovern(A[0],(2,2,2))
A[1] = T.oneovern(A[1],(2,2,2))
res = T.mergeCart(A)
C.convertArrays2File(res, "out.plt")
#  mergeCart (pyTree) 
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
dh = 0.1; n = 11
A = []
a1 = G.cart((0.,0.,0.),(dh,dh,dh),(n,n,n)); a1 = T.oneovern(a1,(2,2,2))
a2 = G.cart((1.,0.,0.),(dh,dh,dh),(n,n,n)); a2 = T.oneovern(a2,(2,2,2))
a3 = G.cart((1.,1.,0.),(dh,dh,dh),(n,n,n))
a4 = G.cart((0.,1.,0.),(dh,dh,dh),(n,n,n))
A = [a1,a2,a3,a4]
for i in range(1,5): A[i1][0] = 'cart'+str(i)
t = C.newPyTree(['Base']); t[2][1][2] += A
t[2][1][2] = T.mergeCart(t[2][1][2])
C.convertPyTree2File(t, "out.cgns")
Split a set of M grids into N parts of same size roughly, provided M < N. Argument multigrid enables to ensure the multigrid level by the splitting, provided the input grids are of that multigrid level.
Parameters: 


Returns:  list of merged Cartesian grids 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitNParts (array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart((0,0,0), (1,1,1), (101,101,41))
b = G.cart((10,0,0), (1,1,1), (121,61,81))
c = G.cart((20,0,0), (1,1,1), (101,61,131))
res = T.splitNParts([a,b,c], 32, multigrid=0, dirs=[1,2,3])
C.convertArrays2File(res, 'out.plt')
#  splitNParts (pyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (81,81,81))
b = G.cart((80,0,0), (1,1,1), (41,81,41))
t = C.newPyTree(['Base',a,b])
t = T.splitNParts(t, 10, multigrid=0, dirs=[1,2,3])
C.convertPyTree2File(t, 'out.cgns')
Argument multigrid enables to ensure the multigrid level by the splitting, provided the input grids are of that multigrid level.
For the pyTree version, boundary conditions are split, but grid connectivity is removed.
Parameters: 


Returns:  list of merged Cartesian grids 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitSize (array) 
import Generator as G
import Transform as T
import Converter as C
a = G.cart((0,0,0),(1,1,1),(50,20,10))
B = T.splitSize(a, 2000, type=0)
C.convertArrays2File(B, 'out.plt')
#  splitSize (pyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0),(1,1,1),(50,20,10))
t = C.newPyTree(['Base',a])
t = T.splitSize(t, 300, type=0)
C.convertPyTree2File(t, 'out.cgns')
Split a curve defined by a 1D structured grid with respect to the curvature angle. If angle is lower than 180sensibility in degrees or greater than 180+sensibility degrees, curve is split.
Parameters: 


Returns:  list of split curves 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitCurvatureAngle (array) 
import Converter as C
import Transform as T
import Geom as D
line = D.line((0.,0.,0.), (1.,1.,0.), 51)
line2 = D.line((1.,1.,0.), (0.,0.,0.), 51)
a = T.join(line2, line)
list = T.splitCurvatureAngle(a, 30.)
C.convertArrays2File(list, 'out.plt')
#  splitCurvatureAngle (pyTree) 
import Converter.PyTree as C
import Geom.PyTree as D
import Transform.PyTree as T
a = D.naca(12,101)
a2 = D.line((1,0,0), (2,0,0), 50)
a = T.join(a, a2)
a2 = D.line((2,0,0), (1,0,0), 50)
a = T.join(a, a2)
zones = T.splitCurvatureAngle(a, 20.)
C.convertPyTree2File(zones+[a], 'out.cgns')
Split a curve defined by a 1D structured grid with respect to the curvature radius, using BSpline approximations. The curve can be closed or not.
Parameters: 


Returns:  list of split curves 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitCurvatureRadius (array) 
import Converter as C
import Transform as T
import Geom as D
pts = C.array('x,y,z', 7, 1, 1)
x = pts[1][0]; y = pts[1][1]; z = pts[1][2]
x[0]= 6.; x[1] = 5.4; x[2]=4.8; x[3] = 2.5; x[4] = 0.3
y[0]=10.; y[1]=0.036; y[2]=5.;y[3]=0.21;y[4]=0.26;y[5]=7.
z[0]=1.; z[1]=1.; z[2]=1.;z[3]=1.;z[4]=1.;z[5]=1.; z[6]=1.
a = D.bezier( pts, 50 )
L = T.splitCurvatureRadius(a)
C.convertArrays2File([a]+L, 'out.plt')
#  splitCurvatureRadius (pyTree)
import Converter.PyTree as C
import Geom.PyTree as D
import Transform.PyTree as T
a = D.naca(12.5000)
zones = T.splitCurvatureRadius(a, 10.)
C.convertPyTree2File(zones+[a], 'out.cgns')
Split an unstructured mesh into connex parts.
Parameters:  a (array or zone) – initial unstructured mesh 

Returns:  list of connex parts 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitConnexity (array) 
import Converter as C
import Transform as T
import Geom as D
a = D.text2D("CASSIOPEE")
B = T.splitConnexity(a)
C.convertArrays2File(B, 'out.plt')
#  splitConnexity (pyTree) 
import Converter.PyTree as C
import Transform.PyTree as T
import Geom.PyTree as D
a = D.text2D("CASSIOPEE")
B = T.splitConnexity(a)
C.convertPyTree2File(B, 'out.cgns')
Split a structured mesh at external nodes connected to an even number of points, meaning that the geometrical point connects an odd number of blocks.
Parameters:  a ([list of arrays] or [list of zones]) – initial set of structured grids 

Returns:  set of structured grids after splitting 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitMultiplePts (array) 
import Generator as G
import Transform as T
import Converter as C
z0 = G.cart((0.,0.,0.),(0.1,0.1,1.),(10,10,1))
z1 = T.subzone(z0,(1,1,1),(5,10,1))
z2 = T.subzone(z0,(5,1,1),(10,5,1))
z3 = T.subzone(z0,(5,5,1),(10,10,1))
zones = [z1,z2,z3]
zones = T.splitMultiplePts(zones,dim=2)
C.convertArrays2File(zones, 'out.plt')
#  splitMultiplePts (pyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
import Connector.PyTree as X
nk = 2
z0 = G.cart((0.,0.,0.),(0.1,0.1,1.),(10,10,nk))
z1 = T.subzone(z0,(1,1,1),(5,10,nk)); z1[0] = 'cart1'
z2 = T.subzone(z0,(5,1,1),(10,5,nk)); z2[0] = 'cart2'
z3 = T.subzone(z0,(5,5,1),(10,10,nk)); z3[0] = 'cart3'
z0 = T.translate(z0,(0.9,0.,0.)); z0[0] = 'cart0'
z4 = G.cart((0.9,0.9,0.),(0.1,0.1,1.),(19,5,nk)); z4[0] = 'cart4'
t = C.newPyTree(['Base',z1,z2,z3,z4])
t = X.connectMatch(t,dim=2)
t = C.fillEmptyBCWith(t, 'wall', 'BCWall', dim=2)
t = T.splitMultiplePts(t, dim=2)
C.convertPyTree2File(t, 'out.cgns')
Split a 1D or 2D mesh at edges sharper than alphaRef. If the input grid is structured, then it returns an unstructured grid (BAR or QUAD)
Parameters: 


Returns:  set of unstructured grids (with no sharp edges) 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitSharpEdges (array) 
import Converter as C
import Transform as T
import Geom as D
import Generator as G
a = D.text3D("A"); a = G.close(a, 1.e4)
B = T.splitSharpEdges(a, 89.)
C.convertArrays2File(B, 'out.plt')
#  splitSharpEdges (pyTree) 
import Converter.PyTree as C
import Transform.PyTree as T
import Geom.PyTree as D
import Generator.PyTree as G
a = D.text3D("A"); a = G.close(a, 1.e3)
B = T.splitSharpEdges(a, 89.)
C.convertPyTree2File(B, 'out.cgns')
Split a curve defined by a ‘BAR’ if it has Tbranches.
Parameters: 


Returns:  set of BAR grids (with no Tbranches) 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitTBranches (array)
import Converter as C
import Generator as G
import Transform as T
a = G.cylinder((0.,0.,0.), 0.5, 1., 360., 0., 10., (50,1,50))
c1 = T.subzone(a,(1,1,1),(50,1,1))
c2 = T.subzone(a,(1,1,50),(50,1,50))
c3 = T.subzone(a,(1,1,1),(1,1,50))
c = [c1,c2,c3]; c = C.convertArray2Hexa(c)
c = T.join(c)
res = T.splitTBranches(c)
C.convertArrays2File(res,"out.plt")
#  splitTBranches (pyTree)
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
a = G.cylinder((0.,0.,0.), 0.5, 1., 360., 0., 10., (50,1,50))
c1 = T.subzone(a,(1,1,1),(50,1,1))
c2 = T.subzone(a,(1,50,1),(50,50,1))
c3 = T.subzone(a,(1,1,1),(1,50,1))
c = [c1,c2,c3]; c = C.convertArray2Hexa(c)
c = T.join(c)
res = T.splitTBranches(c)
C.convertPyTree2File(res, "out.cgns")
Split a unstructured mesh (TRI or BAR only) into manifold pieces.
Parameters:  a (array or zone) – initial mesh (TRI or BAR) 

Returns:  set of TRI or BAR grids 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitManifold (array) 
# Conforming 1 or 2 TRI/BAR together (same type for both operands
import Converter as C
import Generator as G
import Intersector as XOR
import Geom as D
from Geom.Parametrics import base
import Transform as T
s1 = D.sphere( (0,0,0), 1, N=20 )
s2 = D.surface(base['plane'], N=30)
s2 = T.translate(s2, (0.2,0.2,0.2))
s1 = C.convertArray2Tetra(s1); s1 = G.close(s1)
s2 = C.convertArray2Tetra(s2); s2 = G.close(s2)
x = XOR.conformUnstr(s1, s2, 0., 2)
x = T.splitManifold(x)
C.convertArrays2File(x, 'outS.plt')
a = G.cylinder((0.,0.,0.), 0.5, 1., 360., 0., 10., (50,1,50))
c1 = T.subzone(a,(1,1,1),(50,1,1))
c2 = T.subzone(a,(1,1,50),(50,1,50))
c3 = T.subzone(a,(1,1,1),(1,1,50))
c = [c1,c2,c3]; c = C.convertArray2Hexa(c)
c = T.join(c)
C.convertArrays2File([c], 'B.plt')
x = T.splitManifold(c)
C.convertArrays2File(x, 'outB.plt')
#  conformUnstr (pyTree) 
# Conforming 1 or 2 TRI/BAR together (same type for both operands
import Converter.PyTree as C
import Generator.PyTree as G
import Intersector.PyTree as XOR
import Geom.PyTree as D
from Geom.Parametrics import base
import Transform.PyTree as T
s1 = D.sphere((0,0,0), 1, N=20)
s2 = D.surface(base['plane'], N=30)
s2 = T.translate(s2, (0.2,0.2,0.2))
s1 = C.convertArray2Tetra(s1); s1 = G.close(s1)
s2 = C.convertArray2Tetra(s2); s2 = G.close(s2)
x = XOR.conformUnstr(s1, s2, 0., 2)
x = T.splitManifold(x)
C.convertPyTree2File(x, 'outS.cgns')
a = G.cylinder((0.,0.,0.), 0.5, 1., 360., 0., 10., (50,1,50))
c1 = T.subzone(a,(1,1,1),(50,1,1))
c2 = T.subzone(a,(1,50,1),(50,50,1))
c3 = T.subzone(a,(1,1,1),(1,50,1))
c = [c1,c2,c3]; c = C.convertArray2Hexa(c)
c = T.join(c)
x = T.splitManifold(c)
C.convertPyTree2File(x, "outB.cgns")
Split a curve defined by a BAR at index N.
Parameters: 


Returns:  two BARS 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitBAR (array) 
import Generator as G
import Converter as C
import Geom as D
import Transform as T
a = G.cart( (0,0,0), (1,1,1), (50,1,1) )
a = C.convertArray2Tetra(a)
a = G.close(a)
b = T.splitBAR(a, 5)
C.convertArrays2File(b, 'out.plt')
#  splitBAR (pyTree) 
import Generator.PyTree as G
import Converter.PyTree as C
import Geom.PyTree as D
import Transform.PyTree as T
a = G.cart((0,0,0), (1,1,1), (50,1,1))
a = C.convertArray2Tetra(a)
a = G.close(a)
B = T.splitBAR(a, 5)
C.convertPyTree2File(B, 'out.cgns')
Split a triangular mesh into several triangular grids delineated by the polyline of indices idxList in the original TRI mesh.
Parameters: 


Returns:  a set of TRI grids 
Return type:  [list of arrays] or [list of zones] 
Example of use:
#  splitTRI (array) 
import Generator as G
import Converter as C
import Geom as D
import Transform as T
a = D.circle( (0,0,0), 1, N=20 )
a = C.convertArray2Tetra(a)
a = G.close(a)
b = G.T3mesher2D(a)
#C.convertArrays2File([b], 'out.plt')
c = [[9, 25, 27, 30, 29, 28, 34, 38, 0], [29, 23, 19, 20, 24, 29]]
d = T.splitTRI(b, c)
C.convertArrays2File([d[0]], 'out1.plt')
C.convertArrays2File([d[1]], 'out2.plt')
#  splitTRI (PyTree) 
import Generator.PyTree as G
import Converter.PyTree as C
import Geom.PyTree as D
import Transform.PyTree as T
a = D.circle( (0,0,0), 1, N=20 )
a = C.convertArray2Tetra(a)
a = G.close(a)
b = G.T3mesher2D(a)
c = [[9, 25, 27, 30, 29, 28, 34, 38, 0], [29, 23, 19, 20, 24, 29]]
D = T.splitTRI(b, c)
C.convertPyTree2File(D, 'out.cgns')
Deform a surface by moving each point of a vector. The vector field must be defined in a, with the same location.
Exists also as an inplace version (_deform) which modifies a and returns None.
Parameters: 


Returns:  deformed surface mesh 
Return type:  same as a 
Example of use:
#  deform (array) 
import Converter as C
import Generator as G
import Geom as D
import Transform as T
a = D.sphere((0,0,0), 1., 50)
n = G.getNormalMap(a)
n = C.center2Node(n); n[1] = n[1]*10
a = C.addVars([a,n])
b = T.deform(a,['sx','sy','sz'])
C.convertArrays2File([b], 'out.plt')
#  deform (pyTree) 
import Converter.PyTree as C
import Generator.PyTree as G
import Geom.PyTree as D
import Transform.PyTree as T
a = G.cart((0.,0.,0.),(1.,1.,1.),(10,10,10))
C._initVars(a,'dx=10.')
C._initVars(a,'dy=0')
C._initVars(a,'dz=0')
b = T.deform(a)
C.convertPyTree2File(a, 'out.cgns')
Deform a surface a by moving each point of the surface by a scalar field alpha times the surface normals in niter steps
Exists also as an inplace version (_deformNormals) which modifies a and returns None.
Parameters: 


Returns:  deformed surface mesh 
Return type:  same as a 
Example of use:
#  deformNormals (array) 
import Converter as C
import Generator as G
import Geom as D
import Transform as T
a = D.sphere((0,0,0), 1., 50)
a = C.convertArray2Hexa(a)
a = G.close(a)
b = C.initVars(a, 'alpha=0.5*{x}')
b = C.extractVars(b, ['alpha'])
b = T.deformNormals(a, b, niter=2)
C.convertArrays2File([b], 'out.plt')
#  deformNormals (pyTree) 
import Converter.PyTree as C
import Geom.PyTree as D
import Generator.PyTree as G
import Transform.PyTree as T
a = D.sphere6((0,0,0), 1., 10)
a = C.convertArray2Hexa(a)
a = T.join(a); a = G.close(a)
a = C.initVars(a, '{alpha}=0.5*{CoordinateX}')
a = T.deformNormals(a, 'alpha', niter=2)
C.convertPyTree2File(a, 'out.cgns')
Deform a by moving point P of vector V. Argument ‘depth’ controls the depth of deformation. Argument ‘width’ controls the width of deformation.
Exists also as an inplace version (_deformPoint) which modifies a and returns None.
Parameters: 


Returns:  deformed surface mesh 
Return type:  same as a 
Example of use:
#  deformPoint (array) 
import Generator as G
import Transform as T
import Converter as C
a1 = G.cart((0,0,0), (1,1,1), (10,10,1))
a2 = T.deformPoint(a1, (0,0,0), (0.1,0.1,0.1), 0.5, 2.)
C.convertArrays2File([a2], "out.plt")
#  deformPoint (PyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
a = G.cart((0,0,0), (1,1,1), (10,10,1))
a = T.deformPoint(a, (0,0,0), (0.1,0.1,1.), 0.5, 0.4)
C.convertPyTree2File(a, "out.cgns")
Deform a mesh defined by a given surface or a set of surfaces for which a deformation is defined at nodes as a vector field ‘dx,dy,dz’. The surface surfDelta does not necessary match with a border of the meshes. Beta enables to extend the deformation region as multiplication factor of local deformation.
Exists also as an inplace version (_deform) which modifies a and returns None.
Parameters: 


Returns:  deformed mesh 
Return type:  same as a 
Example of use:
#  deformMesh (array) 
import Generator as G
import Transform as T
import Converter as C
import Geom as D
a1 = D.sphere6((0,0,0), 1, 20)
a1 = C.convertArray2Tetra(a1); a1 = T.join(a1)
point = C.getValue(a1, 0)
a2 = T.deformPoint(a1, point, (0.1,0.05,0.2), 0.5, 2.)
delta = C.addVars(a1, ['dx','dy','dz'])
delta = C.extractVars(delta, ['dx','dy','dz'])
delta[1][:,:] = a2[1][:,:]a1[1][:,:]
a1 = C.addVars([a1, delta])
m = D.sphere6((0,0,0), 2, 20)
m = T.deformMesh(m, a1)
C.convertArrays2File(m, "out.plt")
#  deformMesh (pyTree) 
import Generator.PyTree as G
import Transform.PyTree as T
import Converter.PyTree as C
import Geom.PyTree as D
a1 = D.sphere6((0,0,0),1,20)
a1 = C.convertArray2Tetra(a1); a1 = T.join(a1)
point = C.getValue(a1, 'GridCoordinates', 0)
a2 = T.deformPoint(a1, point, (0.1,0.05,0.2), 0.5, 2.)
delta = C.diffArrays(a2,a1)
deltax = C.getField('DCoordinateX',delta)
deltay = C.getField('DCoordinateY',delta)
deltaz = C.getField('DCoordinateZ',delta)
for noz in xrange(len(deltax)):
deltax[noz][0] = 'dx'
deltay[noz][0] = 'dy'
deltaz[noz][0] = 'dz'
a1 = C.setFields(deltax,a1,'nodes')
a1 = C.setFields(deltay,a1,'nodes')
a1 = C.setFields(deltaz,a1,'nodes')
m = D.sphere6((0,0,0),2,20)
m = T.deformMesh(m, a1)
C.convertPyTree2File(m, "out.cgns")
Project a surface mesh a onto a set of surfaces s according to a vector defined for each point of the mesh a. If oriented=0, both directions are used for projection, else the vector direction is used.
Exists also as an inplace version (_deform) which modifies a and returns None.
Parameters: 


Returns:  projected mesh 
Return type:  same as a 
Example of use:
#  projectAllDirs (array) 
import Geom as D
import Converter as C
import Generator as G
import Transform as T
a = D.sphere6((0,0,0), 1., 20)
b = G.cart((1.1,0.1,0.1),(0.03,0.03,0.03), (1,50,50))
n = G.getNormalMap(b)
n = C.center2Node(n)
b = C.addVars([b,n])
c = T.projectAllDirs([b], a, ['sx','sy','sz'])
C.convertArrays2File([b]+c, 'out.plt')
#  projectAllDirs (pyTree) 
import Geom.PyTree as D
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
a = D.sphere((0,0,0), 1., 20)
b = G.cart((1.1,0.1,0.1),(0.1,0.1,0.1), (1,5,5))
b = G.getNormalMap(b)
b = C.center2Node(b,['centers:sx','centers:sy','centers:sz'])
c = T.projectAllDirs(b, a,['sx','sy','sz']); c[0] = 'projection'
C.convertPyTree2File([a,b,c], 'out.cgns')
If oriented=0, both directions are used for projection, else the vector direction is used. If smooth=1, points that cannot be projected are smoothed (available only for structured grids).
Exists also as an inplace version (_deform) which modifies a and returns None.
Parameters: 


Returns:  projected mesh 
Return type:  same as a 
Example of use:
#  projectDir (array) 
import Geom as D
import Converter as C
import Generator as G
import Transform as T
a = D.sphere((0,0,0), 1., 20)
b = G.cart((1.1,0.1,0.1),(0.03,0.03,0.03), (1,50,50))
c = T.projectDir(b, [a], (1.,0,0))
d = T.projectDir([b], [a], (1.,0,0), smooth=1)
C.convertArrays2File([a,b,c]+d, 'out.plt')
#  projectDir (pyTree) 
import Geom.PyTree as D
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
a = D.sphere((0,0,0), 1., 20)
b = G.cart((1.1,0.1,0.1),(0.1,0.1,0.1), (1,5,5))
c = T.projectDir(b, a, (1.,0,0)); c[0] = 'projection'
C.convertPyTree2File([a,b,c], 'out.cgns')
Project a surface mesh a orthogonally onto a set of surfaces s.
Exists also as an inplace version (_deform) which modifies a and returns None.
Parameters: 


Returns:  projected mesh 
Return type:  same as a 
Example of use:
#  projectOrtho (array) 
import Geom as D
import Converter as C
import Generator as G
import Transform as T
a = D.sphere((0,0,0), 1., 300)
b = G.cart((0.5,0.5,1.5),(0.05,0.05,0.1), (20,20,1))
c = T.projectOrtho(b, [a])
C.convertArrays2File([a,b,c], 'out.plt')
#  projectOrtho (pyTree) 
import Geom.PyTree as D
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
a = D.sphere((0,0,0), 1., 20)
b = G.cart((1.1,0.1,0.1),(0.1,0.1,0.1), (1,5,5))
c = T.projectOrtho(b, a); c[0] = 'projection'
C.convertPyTree2File([a,b,c], 'out.cgns')
Project a surface mesh a following smoothed normals onto a set of surfaces s.
Exists also as an inplace version (_deform) which modifies a and returns None.
Parameters: 


Returns:  projected mesh 
Return type:  same as a 
Example of use:
#  projectOrthoSmooth (array) 
import Geom as D
import Converter as C
import Generator as G
import Transform as T
a = D.sphere((0,0,0), 1., 30)
b = G.cart((0.5,0.5,1.5),(0.05,0.05,0.1), (20,20,1))
c = T.projectOrthoSmooth(b, [a], niter=2)
C.convertArrays2File([a,b,c], 'out.plt')
#  projectOrthoSmooth (pyTree) 
import Geom.PyTree as D
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
a = D.sphere((0,0,0), 1., 30)
b = G.cart((0.5,0.5,1.5),(0.05,0.05,0.1), (20,20,1))
c = T.projectOrthoSmooth(b, [a], niter=2)
C.convertPyTree2File([a,b,c], 'out.cgns')
Project a surface mesh a onto a set of surfaces s following rays starting from P.
Exists also as an inplace version (_deform) which modifies a and returns None.
Parameters: 


Returns:  projected mesh 
Return type:  same as a 
Example of use:
#  projectRay (array) 
import Geom as D
import Converter as C
import Generator as G
import Transform as T
a = D.sphere((0,0,0), 1., 20)
b = G.cart((1.1,0.1,0.1),(0.1,0.1,0.1), (1,5,5))
c = T.projectRay(b, [a], (0,0,0))
C.convertArrays2File([a,b,c], 'out.plt')
#  projectRay (pyTree) 
import Geom.PyTree as D
import Converter.PyTree as C
import Generator.PyTree as G
import Transform.PyTree as T
a = D.sphere((0,0,0), 1., 20)
b = G.cart((1.1,0.1,0.1),(0.1,0.1,0.1), (1,5,5))
c = T.projectRay(b, a, (0,0,0)); c[0] = 'projection'
C.convertPyTree2File([a,b,c], 'out.cgns')