Example #1
0
a2 = T.reorder(a2, (-1, 2, 3))
a2[0] = C.getZoneName(a1[0])
t = C.newPyTree(['Base', 2])
t[2][1][2] += [a1, a2, a3]
t = C.initVars(t, 'F', 1.)
t = C.initVars(t, 'centers:G', 2.)
t[2][1][2][0] = C.addBC2Zone(t[2][1][2][0], 'overlap', 'BCOverlap', 'imin')
t = X.connectMatch(t, dim=2)
t = C.fillEmptyBCWith(t, 'wall', 'BCWall', dim=2)
a = T.merge(t, alphaRef=45.)
t = C.newPyTree(['Base', 2])
t[2][1][2] += a
test.testT(t, 3)

# volume grid
a = D.surface(f, N=50)
distrib = G.cart((0., 0., 0.), (0.1, 1, 1), (11, 1, 1))
a = G.addNormalLayers(a, distrib)
b = T.splitSize(a, 5000)
b = X.connectMatch(b, dim=3)
t = C.newPyTree(['Base'])
t[2][1][2] += b
t = C.initVars(t, 'F', 1.)
t = C.initVars(t, 'centers:G', 2.)
t[2][1][2][0] = C.addBC2Zone(t[2][1][2][0], 'overlap', 'BCOverlap', 'imin')
t = C.fillEmptyBCWith(t, 'wall', 'BCWall', dim=3)
b = T.merge(t, dir=2)
t = C.newPyTree(['Base'])
t[2][1][2] += b
test.testT(t, 4)
def addLayers():
    if CTK.t == []: return
    if CTK.__MAINTREE__ <= 0:
        CTK.TXT.insert('START', 'Fail on a temporary tree.\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
        return
    h = CTK.varsFromWidget(VARS[0].get(), type=1)
    if len(h) != 1:
        CTK.TXT.insert('START', 'Layer height is incorrect.\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
        return
    h = h[0]
    N = CTK.varsFromWidget(VARS[1].get(), type=2)
    if len(N) != 1:
        CTK.TXT.insert('START', 'Number of layers is incorrect.\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
        return
    N = N[0]
    smooth = CTK.varsFromWidget(VARS[2].get(), type=2)
    if len(smooth) != 1:
        CTK.TXT.insert('START', 'Smoothing iterations number is incorrect.\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
        return
    smooth = smooth[0]

    nzs = CPlot.getSelectedZones()
    if nzs == []:
        CTK.TXT.insert('START', 'Selection is empty.\n')
        CTK.TXT.insert('START', 'Error: ', 'Error')
        return

    CTK.saveTree()
    zlist = []
    for nz in nzs:
        nob = CTK.Nb[nz] + 1
        noz = CTK.Nz[nz]
        z = CTK.t[2][nob][2][noz]
        zlist.append(z)

    d = G.cart((0, 0, 0), (h, 1, 1), (N + 1, 1, 1))
    fail = False
    errors = []
    try:
        zlist = G.addNormalLayers(zlist, d, niter=smooth)
    except Exception as e:
        fail = True
        errors += [0, str(e)]

    for z in zlist:
        z[0] = C.getZoneName(z[0])  # unique name

    CTK.t = C.addBase2PyTree(CTK.t, 'MESHES')
    base = Internal.getNodeFromName1(CTK.t, 'MESHES')

    if not fail:
        nob = C.getNobOfBase(base, CTK.t)
        for i in zlist:
            CTK.add(CTK.t, nob, -1, i)
        CTK.TXT.insert('START', 'Normal layers added.\n')
    else:
        Panels.displayErrors(errors, header='Error: addNormalLayers')
        CTK.TXT.insert('START',
                       'Add normal layers fails for at least one zone.\n')
        CTK.TXT.insert('START', 'Warning: ', 'Warning')
    (CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
    CTK.TKTREE.updateApp()
    CPlot.render()
# - blankIntersectingCells (pyTree) -
import Converter.PyTree as C
import Generator.PyTree as G
import Geom.PyTree as D
import Connector.PyTree as X
import KCore.test as test
import Transform.PyTree as T

body = D.sphere6((0,0,0),1.,10)
body = T.reorder(body,(-1,2,3))
dh = G.cart((0,0,0),(0.1,1,1),(10,1,1))
a = G.addNormalLayers(body,dh,niter=0)
C._initVars(a,'centers:cellN',1.)
C._initVars(a,'F',2.)
a = C.addBC2Zone(a, 'wall1', 'BCWall', 'kmin')
a = C.addBC2Zone(a, 'overlap1', 'BCOverlap', 'kmax' )
t = C.newPyTree(['Base',a])
t2 = X.blankIntersectingCells(t, depth=1)
test.testT(t2,1)
Example #4
0
                                   0), C.getValue(a1, 'CoordinateZ', 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')

# 2D paroi
m = D.sphere6((0, 0, 0), 1, N=18)
m = T.deformMesh(m, a1)
test.testT(m, 1)

# 2D
m = D.sphere6((0, 0, 0), 2, N=18)
m2 = T.deformMesh(m, a1)
test.testT(m2, 2)

# 3D
m = D.sphere6((0, 0, 0), 2, N=18)
dk = G.cart((0, 0, 0), (0.1, 1, 1), (3, 1, 1))
m = G.addNormalLayers(m, dk, niter=100)
m2 = T.deformMesh(m, a1)
test.testT(m2, 3)
Example #5
0
import Converter.PyTree as C
import Generator.PyTree as G
import Converter.Internal as Internal
import Connector.PyTree as X
import Geom.PyTree as D
import KCore.test as test

d = 2
a = D.sphere6((0, 0, 0), 0.5, N=20)
dk = G.cart((0, 0, 0), (0.01, 1, 1), (11, 1, 1))
a = G.addNormalLayers(a, dk)
t = C.newPyTree(['Base'])
t[2][1][2] = a
t = X.connectMatch(t, dim=3)
t = Internal.addGhostCells(t, t, d, adaptBCs=1)
#---------
# Centers
#---------
t = C.initVars(t, 'centers:F=0.')
tc = C.node2Center(t)
tc = C.initVars(tc, 'F={CoordinateX}*{CoordinateY}')
# stockage direct
t1 = X.setInterpDataForGhostCells__(t, tc, storage='direct', loc='centers')
t1 = X.setInterpTransfers(t1, tc, variables=['F'])
test.testT(t1, 1)

# stockage inverse
tc1 = X.setInterpDataForGhostCells__(t, tc, storage='inverse', loc='centers')
t1 = X.setInterpTransfers(t, tc1, variables=['F'])
test.testT(t1, 2)
#---------
# - rmGhostCells (pyTree) -
import Generator.PyTree as G
import Converter.PyTree as C
import Geom.PyTree as D
import Converter.Internal as Internal
import Transform.PyTree as T
import Connector.PyTree as X
import KCore.test as test

# 3D sur une zone
a = D.sphere((0, 0, 0), 1, N=10)
dhk = G.cart((0, 0, 0), (0.1, 1, 1), (2, 1, 1))
a = G.addNormalLayers(a, dhk)
a = C.convertArray2NGon(a)
a = G.close(a)
a = C.initVars(a, 'centers:F={centers:CoordinateX}')
a = C.initVars(a, 'Density={CoordinateX}')
t = C.newPyTree(['Base'])
t[2][1][2] = [a]
t = Internal.addGhostCells(t, t, 2, adaptBCs=0, fillCorner=1)
t = Internal.rmGhostCells(t, t, 2)
test.testT(t, 1)

# 3D sur un arbre
a = D.sphere((0, 0, 0), 1, N=10)
dhk = G.cart((0, 0, 0), (0.1, 1, 1), (2, 1, 1))
a = G.addNormalLayers(a, dhk)
a = C.convertArray2NGon(a)
a = G.close(a)
a = C.initVars(a, 'centers:F={centers:CoordinateX}**2')
a = C.initVars(a, 'Density=3*{CoordinateX}+2*{CoordinateY}')
# - addNormalLayers (pyTree) -
import Generator.PyTree as G
import Converter.PyTree as C
import Transform.PyTree as T
import Geom.PyTree as D

d = G.cart((0.1, 0., 0.), (0.1, 1, 1), (2, 1, 1))
a = D.sphere((0, 0, 0), 1, 50)
a = D.line((0, 0, 0), (1, 1, 0), 3)
b = G.addNormalLayers(a, d)
d = G.cart((0.1, 0., 0.), (-0.1, 1, 1), (2, 1, 1))
c = G.addNormalLayers(a, d)

a = T.join(b, c)
C.convertPyTree2File(a, 'out.cgns')
# - addNormalLayers (pyTree) -
import Generator.PyTree as G
import Converter.PyTree as C
import Geom.PyTree as D
import KCore.test as test

# sur une zone structuree
d = G.cart((0.1, 0., 0.), (0.1, 1, 1), (2, 1, 1))
a = D.sphere((0, 0, 0), 1, 50)
a = G.addNormalLayers(a, d, niter=2)
test.testT(a, 1)

# sur une surface TRI
a = D.sphere((0, 0, 0), 1, 50)
a = C.convertArray2Tetra(a)
a = G.addNormalLayers(a, d, niter=2)
test.testT(a, 2)

# sur une surface QUAD
a = D.sphere((0, 0, 0), 1, 50)
a = C.convertArray2Hexa(a)
a = G.addNormalLayers(a, d, niter=2)
test.testT(a, 3)

# sur une liste de zones structurees
d = G.cart((0., 0., 0.), (0.1, 1, 1), (3, 1, 1))
a = D.sphere6((0, 0, 0), 1, 20)
a = C.initVars(a, 'Density', 2.)
a = C.initVars(a, 'centers:cellN', 1.)
a = G.addNormalLayers(a, d, niter=2)
test.testT(a, 4)
Example #9
0
import numpy

import Converter.PyTree as C
import Converter.Internal as Internal
import Converter
import Dist2Walls.PyTree as DTW
import Geom.PyTree as D
import Generator.PyTree as G
import Connector.PyTree as X

# Creation of the structured multiblock mesh
# kmin=1 define the wall BC
m = D.sphere6((0, 0, 0), 1., N=10)
di = G.cart((0., 0., 0.), (0.1, 1., 1.), (11, 1, 1))
m = G.addNormalLayers(m, di)
m = C.addBC2Zone(m, 'wall', 'BCWall', 'kmin')
m = C.addBC2Zone(m, 'nref', 'BCFarfield', 'kmax')
m = X.connectMatch(m)
t = C.newPyTree(['Base'])
t[2][1][2] = m
t = C.initVars(t, 'centers:cellN', 1.)
#
# Get the wall surfaces
#
walls = C.extractBCOfType(t, 'BCWall')
walls += C.extractBCOfType(t, 'BCWallViscous')
walls += C.extractBCOfType(t, 'BCWallInviscid')

# Convert the wall border to centers
bodies = C.node2Center(walls)
Example #10
0
# Test 1
# Tet mask

s1 = D.sphere6((0,0,0), 1., 20, ntype='TRI')
s2 = D.sphere6((1,0,0), 1.5, N=20, ntype='TRI')
s2 = T.reorder(s2, (1,))
#C.convertPyTree2File(s2, 's2.cgns')

snear = 0.15
hWall = 0.1
raison = 1.2
smoothIter = 20
nlayer = 3
dlayer = hWall*(1.-raison**nlayer)/(1.-raison);
d = G.cart((0.,0.,0.), (dlayer/nlayer,1,1), (nlayer,1,1))
penta = G.addNormalLayers(s2, d, check=0, niter=smoothIter)
#C.convertPyTree2File(penta, 'penta.cgns')
t = C.newPyTree(['Pentas']); t[2][1][2].append(penta)
# Blanking
C._initVars(t, 'centers:cellN', 1.)
t = X.blankCellsTri(t, [[s1]], [], blankingType="cell_intersect", tol=1.e-12)
#C.convertPyTree2File(t, 'out.cgns')
test.testT(t,1)

s2 = D.sphere6((1,0,0), 1.5, N=20, ntype='QUAD')
pyras = G.quad2Pyra(s2, hratio=1.)
t = C.newPyTree(['Pyras']); t[2][1][2].append(pyras)
# Blanking
C._initVars(t, 'centers:cellN', 1.)
t = X.blankCellsTri(t, [[s1]], [], blankingType="cell_intersect", tol=1.e-12)
#C.convertPyTree2File(t, 'out2.cgns')