# - dist2WallsEikonal (pyTree) -
import Converter.PyTree as C
import Connector.PyTree as X
import Converter.Internal as Internal
import Dist2Walls.PyTree as DTW
import Geom.PyTree as D
import Generator.PyTree as G
import numpy
DEPTH = 2
snear = 0.4; vmin = 21
# Init wall
body = D.circle((0,0,0),1.,N=60)
res = G.octree([body],[snear], dfar=5., balancing=1)
res = G.octree2Struct(res, vmin=vmin, ext=DEPTH+1,merged=1)
t = C.newPyTree(['Base']); t[2][1][2] = res
# Mark solid and fluid points
t = X.applyBCOverlaps(t,depth=DEPTH,loc='nodes')
tc = Internal.copyRef(t)
tc = X.setInterpData(t,tc,loc='nodes',storage="inverse")
C._initVars(t,"cellN",1.)
t = X.blankCells(t, [[body]], numpy.array([[1]]), blankingType='node_in')
t = X.setHoleInterpolatedPoints(t,depth=1,loc='nodes')
C._initVars(t,'flag=({cellN}>1.)')
t = DTW.distance2WallsEikonal(t,body,tc=tc,DEPTH=DEPTH,nitmax=10)
C.convertPyTree2File(t, 'out.cgns')
import Transform.PyTree as T import Initiator.PyTree as I import KCore.test as test import sys a = G.cart((-1, -1, -1), (0.04, 0.04, 1), (51, 51, 3)) s = G.cylinder((0, 0, -1), 0, 0.4, 360, 0, 4, (30, 30, 5)) s = C.convertArray2Tetra(s) s = T.join(s) s = P.exteriorFaces(s) t = C.newPyTree(['Base']) t[2][1][2] = [a] # Blanking bodies = [[s]] BM = N.array([[1]], N.int32) t = X.blankCells(t, bodies, BM, blankingType='center_in') t = X.setHoleInterpolatedPoints(t, depth=-2) # Dist2Walls t = DTW.distance2Walls(t, [s], type='ortho', loc='centers', signed=1) t = C.center2Node(t, 'centers:TurbulentDistance') # Gradient de distance localise en centres => normales t = P.computeGrad(t, 'TurbulentDistance') t = I.initConst(t, MInf=0.2, loc='centers') tc = C.node2Center(t) t = X.setIBCData(t, tc, loc='centers', storage='direct') #test avec arbre tc compact zones = Internal.getNodesFromType2(t, 'Zone_t') X.miseAPlatDonnorTree__(zones, t, procDict=None) t2 = X.setInterpTransfers(t, tc, bcType=0, varType=1)
vol
Returns
-------
"""
if c == 0. and vol > volmin:
return 1.
else:
return 0.
# Refine the octree inside the sphere until all the elements inside the
# sphere are of finest level
end = 0
while end == 0:
t = X.blankCells(t, [[a]], BM, blankingType='center_in')
t = G.getVolumeMap(t)
volmin = C.getMinValue(t, 'centers:vol')
t = C.initVars(t, 'centers:indicator', F, ['centers:cellN', 'centers:vol'])
end = 1
if C.getMaxValue(t, 'centers:indicator') == 1.:
end = 0
# Maintien du niveau de raffinement le plus fin
o = t[2][1][2][0]
o = G.adaptOctree(o, 'centers:indicator', balancing=1)
# Sortie
t = C.newPyTree(['Base'])
t[2][1][2] += [o]
C.convertPyTree2File(t, 'out.cgns')
# - blankCells (pyTree) - import Converter.PyTree as C import Connector.PyTree as X import Generator.PyTree as G import Geom.PyTree as D import Transform.PyTree as T surf = D.sphere((0, 0, 0), 0.5, 20) a = G.cart((-1., -1., -1.), (0.1, 0.1, 0.1), (20, 20, 20)) t = C.newPyTree(['Cart']) t[2][1][2].append(a) t = C.initVars(t, 'centers:cellN', 1.) bodies = [[surf]] # Matrice de masquage (arbre d'assemblage) import numpy BM = numpy.array([[1]]) t = X.blankCells(t, bodies, BM, blankingType='cell_intersect', delta=0.) C.convertPyTree2File(t, 'out.cgns')
import Converter.PyTree as C
import Connector.PyTree as X
import Generator.PyTree as G
import Geom.PyTree as D
import KCore.test as test
surf = D.circle((0,0,0), 0.5, 20)
a = G.cart((-1.,-1.,0.),(0.1,0.1,1), (20,20,1))
C._addBC2Zone(a, 'ov', 'BCOverlap', 'jmin')
t = C.newPyTree(['Cart',2,a])
t[2][1] = C.addState(t[2][1], 'EquationDimension', 2)
C._fillEmptyBCWith(t, 'wall', 'BCWall')
C._addVars(t, 'Density')
C._initVars(t, 'centers:cellN', 1.)
bodies = [[surf]]
criterions = ['cell_intersect', 'cell_intersect_opt', 'center_in']
# Matrice de masquage (arbre d'assemblage)
import numpy
BM = numpy.array([[1]])
c = 1
for delta in [0.,0.1]:
for type in criterions:
if (type == 'cell_intersect_opt' and delta > 0): c += 1
else:
t2 = X.blankCells(t, bodies, BM,
blankingType=type, delta=delta,
dim=2)
test.testT(t2,c)
c += 1
def adaptInsideOctree():
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
# EquationDimension
node = Internal.getNodeFromName(CTK.t, 'EquationDimension')
if node is not None: dim = Internal.getValue(node)
else:
CTK.TXT.insert('START',
'EquationDimension not found (tkState). Using 3D.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
dim = 3
nzs = CPlot.getSelectedZones()
if (nzs == []):
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
snearsarg = VARS[0].get()
try:
volmin = float(snearsarg)
volmin = volmin**dim
except:
CTK.TXT.insert('START', 'snear is invalid.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
snearsarg = snearsarg.split(';')
for s in snearsarg:
snears.append(float(s))
# Octree meshes
tp = C.newPyTree(['Base'])
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
tp[2][1][2].append(z)
# surfaces des corps
name = VARS[6].get()
names = name.split(';')
surfaces = []
for v in names:
v = v.lstrip()
v = v.rstrip()
sname = v.split('/', 1)
bases = Internal.getNodesFromName1(CTK.t, sname[0])
if (bases != []):
nodes = Internal.getNodesFromType1(bases[0], 'Zone_t')
for z in nodes:
if (z[0] == sname[1]): surfaces.append(z)
if (len(surfaces) == 0):
CTK.TXT.insert('START', 'Invalid body surface.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
# Blank
CTK.saveTree()
BM = numpy.zeros((1, 1), numpy.int32)
BM[0, 0] = 1
end = 0
count = 0
while end == 0:
tp = X.blankCells(tp, [surfaces],
blankingMatrix=BM,
blankingType='center_in',
dim=dim)
tp = G.getVolumeMap(tp)
C._initVars(
tp,
'{centers:indicator}=({centers:cellN}<1.)*({centers:vol}>%20.16g)'
% volmin)
end = 1
if C.getMaxValue(tp, 'centers:indicator') == 1.: end = 0
for noz in xrange(len(tp[2][1][2])):
tp[2][1][2][noz] = G.adaptOctree(tp[2][1][2][noz],
'centers:indicator',
balancing=1)
count += 1
# Back to tree
c = 0
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = tp[2][1][2][c]
CTK.t[2][nob][2][noz] = z
c += 1
fail = False
#C._fillMissingVariables(CTK.t)
if fail == False:
CTK.TXT.insert('START', 'Adapt octree computed.\n')
else:
CTK.TXT.insert('START', 'Adapt octree failed.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
(CTK.Nb, CTK.Nz) = CPlot.updateCPlotNumbering(CTK.t)
CTK.TKTREE.updateApp()
CPlot.render()
def blank():
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
# type
type = VARS[8].get()
# EquationDimension
node = Internal.getNodeFromName(CTK.t, 'EquationDimension')
if node is not None: dim = Internal.getValue(node)
else:
CTK.TXT.insert('START',
'EquationDimension not found (tkState). Using 3D.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
dim = 3
# Blanking surfaces
name = VARS[6].get()
names = name.split(';')
surfaces = []
for v in names:
v = v.lstrip()
v = v.rstrip()
sname = v.split('/', 1)
bases = Internal.getNodesFromName1(CTK.t, sname[0])
if bases != []:
nodes = Internal.getNodesFromType1(bases[0], 'Zone_t')
for z in nodes:
if z[0] == sname[1]: surfaces.append(z)
# Reglages XRay
delta = float(VARS[1].get())
tol = float(VARS[2].get())
# Creation de l'arbre temporaire
nzs = CPlot.getSelectedZones()
if nzs == []:
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
t = C.newPyTree(['Base'])
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
t[2][1][2].append(z)
# Create blanking Matrix
BM = numpy.zeros((1, 1), numpy.int32)
BM[0, 0] = 1
# BlankCells
CTK.saveTree()
t = X.blankCells(t, [surfaces],
blankingMatrix=BM,
blankingType=type,
delta=delta,
dim=dim,
tol=tol)
# Back to tree
c = 0
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = t[2][1][2][c]
CTK.t[2][nob][2][noz] = z
c += 1
#C._fillMissingVariables(CTK.t)
CTK.TXT.insert('START', 'Blanking done.\n')
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
xmax = BB[3] ymax = BB[4] zmax = BB[5]+0.5 hi = (xmax-xmin)/(ni-1) hj = (ymax-ymin)/(nj-1) h = min(hi, hj) ni = int((xmax-xmin)/h)+7 nj = int((ymax-ymin)/h)+7 b = G.cart((xmin-3*h, ymin-3*h, zmin), (h, h, 1.), (ni, nj, nk)) t = C.newPyTree(['Cart']) t[2][1][2].append(b) # Masquage t = C.initVars(t, 'cellN', 1) BM = numpy.array([[1]]) t = X.blankCells(t, [[s2]], BM, blankingType='node_in', dim=2) # Adapte le front de la grille a la surface dim = Internal.getZoneDim(b) t = T.subzone(t, (1, 1, 2), (dim[1], dim[2], 2)) t = G.snapFront(t, [s2]) t = C.addBase2PyTree(t, 'Surface', cellDim=2) s2 = C.initVars(s2, 'cellN', 1) t[2][2][2].append(s2) C.convertPyTree2File(t, 'out.cgns')
def bodyFit():
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
# EquationDimension
node = Internal.getNodeFromName(CTK.t, 'EquationDimension')
if node is not None: dim = Internal.getValue(node)
else:
CTK.TXT.insert('START',
'EquationDimension not found (tkState). Using 3D.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
dim = 3
nzs = CPlot.getSelectedZones()
if (nzs == []):
CTK.TXT.insert('START', 'Selection is empty.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
# Blanking
tp = C.newPyTree(['Base'])
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
tp[2][1][2].append(z)
# surfaces des corps
name = VARS[6].get()
names = name.split(';')
surfaces = []
for v in names:
v = v.lstrip()
v = v.rstrip()
sname = v.split('/', 1)
bases = Internal.getNodesFromName1(CTK.t, sname[0])
if (bases != []):
nodes = Internal.getNodesFromType1(bases[0], 'Zone_t')
for z in nodes:
if (z[0] == sname[1]): surfaces.append(z)
if (len(surfaces) == 0):
CTK.TXT.insert('START', 'Invalid body surface.\n')
CTK.TXT.insert('START', 'Error: ', 'Error')
return
# Blank
BM = numpy.zeros((1, 1), numpy.int32)
BM[0, 0] = 1
tp = X.blankCells(tp, [surfaces],
blankingMatrix=BM,
blankingType='node_in',
dim=dim)
CTK.saveTree()
# Back to tree
c = 0
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = tp[2][1][2][c]
CTK.t[2][nob][2][noz] = z
c += 1
# Snap
fail = False
errors = []
for nz in nzs:
nob = CTK.Nb[nz] + 1
noz = CTK.Nz[nz]
z = CTK.t[2][nob][2][noz]
try:
z = G.snapFront(z, surfaces, optimized=2)
CTK.t[2][nob][2][noz] = z
except Exception as e:
fail = True
errors += [0, str(e)]
#C._fillMissingVariables(CTK.t)
if fail == False:
CTK.TXT.insert('START', 'Snapped to body.\n')
else:
Panels.displayErrors(errors, header='Error: snapFront')
CTK.TXT.insert('START', 'Snap fails for at least one zone.\n')
CTK.TXT.insert('START', 'Warning: ', 'Warning')
CTK.TKTREE.updateApp()
CTK.display(CTK.t)
NIT = 10
DEPTH = 2
# Bloc cartesien
N = 128
h = 0.1
a = G.cart((0., 0., 0.), (h, h, h), (N, N, 1))
# Init wall
sphere = D.sphere((6.4, 6.4, 0), 1., 100)
sphere = C.convertArray2Tetra(sphere)
sphere = G.close(sphere)
t = C.newPyTree(['Base', a])
for it in range(NIT):
T._translate(sphere, (0.1 * it, 0, 0))
C._initVars(t, "cellN", 1.)
t = X.blankCells(t, [[sphere]], numpy.array([[1]]), blankingType='node_in')
t = X.setHoleInterpolatedPoints(t, depth=1, loc='nodes')
C._initVars(t, '{flag}=({cellN}>1.)')
t = DTW.distance2WallsEikonal(t, sphere, DEPTH=DEPTH, nitmax=10)
test.testT(t, 1)
# Centers
t = C.newPyTree(['Base'])
t[2][1][2] = [a]
sphere = D.sphere((6.4, 6.4, 0), 1., 100)
sphere = C.convertArray2Tetra(sphere)
sphere = G.close(sphere)
for it in range(NIT):
T._translate(sphere, (0.1 * it, 0, 0))
C._initVars(t, "centers:cellN", 1.)
t = X.blankCells(t, [[sphere]],
import Transform.PyTree as T
import Connector.PyTree as X
import Converter.Internal as Internal
import numpy
rank = Cmpi.rank
size = Cmpi.size
# lecture des corps servant a masquer
bodies = C.convertFile2PyTree('walls.cgns')
bodies = Internal.getNodesFromType(bodies, 'Zone_t')
# lecture du squelette
a = Cmpi.convertFile2SkeletonTree('in.cgns')
# equilibrage
(a, dic) = Distributor2.distribute(a, NProc=size, algorithm='fast', useCom=0)
# load des zones locales dans le squelette
a = Cmpi.readZones(a, 'in.cgns', proc=rank)
# Passage en arbre partiel
a = Cmpi.convert2PartialTree(a)
# Blanking local
BM = numpy.array([[1]])
a = X.blankCells(a, [bodies], BM, blankingType='node_in', dim=3)
# Reconstruit l'arbre complet a l'ecriture
Cmpi.convertPyTree2File(a, 'out.cgns')
import Transform.PyTree as T import KCore.test as test import numpy surf = D.sphere((0,0,0), 0.5, 20) T._rotate(surf,(0.,0.,0.),(0.,1.,0.), 90.) a = G.cart((-1.,-1.,-1.),(0.1,0.1,0.1), (20,20,20)) C._addBC2Zone(a, 'ov', 'BCOverlap', 'jmin') t = C.newPyTree(['Cart',a]) t[2][1] = C.addState(t[2][1], 'EquationDimension', 3) C._fillEmptyBCWith(t, 'wall', 'BCWall') C._addVars(t, 'Density') bodies = [[surf]] C._initVars(t, 'centers:cellN', 1.) # Matrice de masquage (arbre d'assemblage) BM = numpy.array([[1]]) t2 = X.blankCells(t, bodies, BM) test.testT(t2, 1) # in place C._initVars(t2, 'centers:cellN', 1.) X._blankCells(t2, bodies, BM) test.testT(t2,1) # masque inverse BM = numpy.array([[-1]]) t2 = X.blankCells(t, bodies, BM) test.testT(t2,2)
t = C.addBase2PyTree(t, 'CARTESIAN')
t[2][2][2] = res
# ajout d un plan en k
t = T.addkplane(t)
#
#---------------------------
# Assemblage Chimere
#---------------------------
DEPTH = 2
# bodies description
bodies = []
bases = Internal.getNodesFromType(t, 'CGNSBase_t')
for b in bases:
walls = C.extractBCOfType(b, 'BCWall')
if walls != []: bodies.append(walls)
# blanking
BM = numpy.array([[0], [1]])
t = X.blankCells(t, bodies, BM, depth=DEPTH, dim=2)
t = X.setHoleInterpolatedPoints(t, depth=DEPTH)
t = X.applyBCOverlaps(t, depth=DEPTH)
t = X.optimizeOverlap(t, priorities=['Cylindre1', 0, 'CARTESIAN', 1])
t = X.maximizeBlankedCells(t, depth=DEPTH)
t = X.setInterpolations(t, loc='cell')
# Arbre a la Cassiopee
C.convertPyTree2File(t, 'out_cassiopee.cgns')
# Arbre a la elsA
t = CE.convert2elsAxdt(t)
C.convertPyTree2File(t, 'out_elsa.cgns')
# ============================================================================== # 1. Set cellN to 2 to centers near overlap BCs # ============================================================================== t = X.applyBCOverlaps(t, depth=2) # ============================================================================== # 2. Blanking # ============================================================================== # bodies description bodyC1 = C.extractBCOfType(t[2][1][2], 'BCWall') bodyC2 = C.extractBCOfType(t[2][2][2], 'BCWall') bodies = [bodyC1, bodyC2] # blanking matrix BM = numpy.array([[0, 1], [1, 0], [1, 1]]) # blanking t = X.blankCells(t, bodies, BM, depth=2, dim=2) # set interpolated cells around interpolated points t = X.setHoleInterpolatedPoints(t, depth=2) # ============================================================================== # 3. Overlap optimisation with a high priority to cylinders # ============================================================================== t = X.optimizeOverlap(t, priorities=['Corps1', 0, 'Corps2', 0, 'Bgrd', 1]) t = X.maximizeBlankedCells(t, depth=2) # ============================================================================== # 4. Convert indices of cellN = 0 into OversetHoles nodes # ============================================================================== t = X.cellN2OversetHoles(t) # ============================================================================== # 5. Computes Chimera connectivity # ============================================================================== t = X.setInterpolations(t, loc='cell')
