def test_09NodeDelete(self):
import CGNS.PAT.cgnsutils as CGU
import CGNS.PAT.cgnserrors as CGE
import CGNS.PAT.cgnskeywords as CGK
import numpy
n = CGU.nodeCreate('Base', numpy.array([3, 3]), [], CGK.CGNSBase_ts)
r = CGU.nodeCreate('ReferenceState', None, [], CGK.ReferenceState_ts, parent=n)
d = CGU.nodeCreate('Data', numpy.array([3.14]), [], CGK.DataArray_ts, parent=r)
self.assertIsNotNone(CGU.hasChildName(r, 'Data'))
CGU.nodeDelete(n, d)
self.assertIsNone(CGU.hasChildName(r, 'Data'))
d = CGU.nodeCreate('DataZ', numpy.array([3.14]), [], CGK.DataArray_ts, parent=r)
self.assertIsNotNone(CGU.hasChildName(r, 'DataZ'))
CGU.nodeDelete(r, d)
self.assertIsNone(CGU.hasChildName(r, 'DataZ'))
CGU.nodeDelete(r, d)
self.assertIsNone(CGU.hasChildName(r, 'DataZ'))
n = CGU.nodeCreate('Base', numpy.array([3, 3]), [], CGK.CGNSBase_ts)
r = CGU.nodeCreate('ReferenceState', None, [], CGK.ReferenceState_ts, parent=n)
d = CGU.nodeCreate('Data', numpy.array([3.14]), [], CGK.DataArray_ts, parent=r)
self.assertIsNotNone(CGU.getNodeByPath(n, '/Base/ReferenceState/Data'))
CGU.nodeDelete(n, d)
self.assertIsNone(CGU.hasChildName(r, 'Data'))
n = CGU.nodeCreate('Base', numpy.array([3, 3]), [], CGK.CGNSBase_ts)
r = CGU.nodeCreate('ReferenceState', None, [], CGK.ReferenceState_ts, parent=n)
d = CGU.nodeCreate('Data', numpy.array([3.14]), [], CGK.DataArray_ts, parent=r)
self.assertIsNotNone(CGU.getNodeByPath(n, '/Base/ReferenceState/Data'))
CGU.removeChildByName(r, 'Data')
self.assertIsNone(CGU.hasChildName(r, 'Data'))
def Zone_t(self, pth, node, parent, tree, log):
rs = CGM.CHECK_OK
zt = CGU.hasChildName(node, CGK.ZoneType_s)
zv = []
if zt is not None:
if CGU.stringValueMatches(zt, CGK.Structured_s):
cd = self.context[CGK.CellDimension_s][pth]
self.context[CGK.IndexDimension_s][pth] = cd
elif CGU.stringValueMatches(zt, CGK.Unstructured_s):
self.context[CGK.IndexDimension_s][pth] = 1
shp = (self.context[CGK.IndexDimension_s][pth], 3)
if CGU.getShape(node) != shp:
rs = log.push(pth, 'S009', CGU.getShape(node))
elif CGU.stringValueMatches(zt, CGK.Structured_s):
zd = node[1]
for nd in range(self.context[CGK.IndexDimension_s][pth]):
zv.append(zd[nd][0])
if ((zd[nd][1] != zd[nd][0] - 1) or (zd[nd][2] != 0)):
rs = log.push(pth, 'S010')
else:
zv.append(node[1][0][0])
self.context[CGK.VertexSize_s][pth] = tuple(zv)
if CGU.hasChildNodeOfType(node, CGK.FamilyName_ts):
basepath = [CGK.CGNSTree_ts, parent[0], node[0]]
searchpath = basepath + [CGK.FamilyName_ts]
famlist1 = CGU.getAllNodesByTypeOrNameList(tree, searchpath)
searchpath = basepath + [CGK.AdditionalFamilyName_ts]
famlist2 = CGU.getAllNodesByTypeOrNameList(tree, searchpath)
for (famlist, diagmessage) in ((famlist1, 'S301'), (famlist2,
'S302')):
for fampath in famlist:
famdefinition = CGU.getNodeByPath(tree, fampath)
if (famdefinition[1] is None):
rs = log.push(pth, 'S300')
else:
famtarget = famdefinition[1].tostring().rstrip()
famtargetpath = "/%s/%s" % (parent[0], famtarget)
if (famtargetpath not in self.context):
famtargetnode = CGU.getNodeByPath(
tree, famtargetpath)
if (famtargetnode is None):
rs = log.push(pth, diagmessage, famtarget)
else:
self.context[famtargetpath][pth] = True
if (not CGU.hasChildType(node, CGK.GridCoordinates_ts)):
rs = log.push(pth, 'S602')
elif (not CGU.hasChildName(node, CGK.GridCoordinates_s)):
rs = log.push(pth, 'S603')
if (not CGU.hasChildType(node, CGK.ZoneBC_ts)):
rs = log.push(pth, 'S604')
return rs
def CGNSBase_t(self, pth, node, parent, tree, log):
rs = CGM.CHECK_OK
(cd, pd) = (0, 0)
if not CGU.hasChildNodeOfType(node, CGK.Zone_ts):
rs = log.push(pth, 'U101')
else:
target = [CGK.CGNSTree_ts, node[0], CGK.Zone_ts, CGK.ZoneType_s]
plist = CGU.getAllNodesByTypeOrNameList(tree, target)
found = False
for p in plist:
if (CGU.stringValueMatches(CGU.getNodeByPath(tree, p),
CGK.Structured_s)):
found = True
if not found:
rs = log.push(pth, 'U102')
if not CGU.hasChildNodeOfType(node, CGK.ReferenceState_ts):
rs = log.push(pth, 'U103')
if CGU.getShape(node) != (2,):
rs = log.push(pth, 'S009', CGU.getShape(node))
else:
cd = node[1][0]
pd = node[1][1]
allowedvalues = ((1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3))
if (cd, pd) not in allowedvalues:
rs = log.push(pth, 'S010', (cd, pd))
self.context[CGK.CellDimension_s] = cd
self.context[CGK.PhysicalDimension_s] = pd
return rs
def checkTree(self, T, trace=False, stop=False):
self._stop = stop
self._trace = trace
status1 = CGM.CHECK_GOOD
if (self._trace):
print('### Parsing node paths...')
status1 = self.checkTreeStructure(T)
if (status1 != CGM.CHECK_GOOD):
return status1
paths = CGU.getPathFullTree(T, width=True)
sz = len(paths) + 1
ct = 1
if (not hasattr(self, 'methods')):
self.methods = []
for m in inspect.getmembers(self):
if ((m[0][-2:] == '_t') or (m[0][-2:] == '_n')
or (m[0][-3:] == '_ts')):
self.methods += [m[0]]
for path in ['/'] + paths:
if (self._trace):
print('### Check node [%.6d/%.6d]\r' % (ct, sz), )
node = CGU.getNodeByPath(T, path)
status2 = CGM.CHECK_GOOD
if (node is None):
status2 = self.log.push(path, 'G0005', path)
if (self._stop):
raise CGE.cgnsException(-1)
if (status2 == CGM.CHECK_GOOD):
status2 = self.checkLeaf(T, path, node)
status1 = status2
ct += 1
if self._trace:
print("")
return status1
def parseTree(filename):
flags = CGM.S2P_DEFAULT
(tree, l) = CGM.load(filename, flags, 0, None, [], None)
typepath = [CGK.CGNSTree_ts, CGK.CGNSBase_ts, CGK.Zone_ts, CGK.Elements_ts]
elist = CGU.getAllNodesByTypeList(tree, typepath)
sn = 0
sl = []
sp = ARU.SectionParse()
mr = 1
for e in elist:
print('Parse ', e)
sn += 1
ne = CGU.getNodeByPath(tree, e)[1]
et = ne[0]
eb = ne[1]
ea = CGU.getNodeByPath(tree, e + '/' + CGK.ElementConnectivity_s)[1]
if (et in sp.QUAD_SURFACE):
sl.append(sp.extQuadFacesPoints(ea, et, sn, mr, eb))
if (et in sp.TRI_SURFACE):
sl.append(sp.extTriFacesPoints(ea, et, sn, mr, eb))
mr = sl[-1][-1]
def getBCbyFamily(T, family):
"""Finds all BC that belongs to a family.
Works with more than one base.
Returns a list of path, you have to use getNodeByPath to retrieve
the actual node."""
result = []
fpath = [
CGK.CGNSTree_ts, CGK.CGNSBase_t, CGK.Zone_t, CGK.ZoneBC_t, CGK.BC_t,
CGK.FamilyName_t
]
flist = CGU.getAllNodesByTypeOrNameList(T, fpath)
for famnamepath in flist:
fnode = CGU.getNodeByPath(T, famnamepath)
if (CGU.stringValueMatches(fnode, family)):
bcpath = CGU.getAncestor(famnamepath)
result.append(bcpath)
return result
def test_08NodeRetrieval(self):
import CGNS.PAT.cgnsutils as CGU
import CGNS.PAT.cgnserrors as CGE
import CGNS.PAT.cgnskeywords as CGK
self.genTree()
p1 = '/CGNSTree/{Base#1}/{Zone-B}'
self.assertEqual(CGU.getNodeByPath(self.T, p1)[0], '{Zone-B}')
p2 = '/CGNSTree/.///{Base#1}/{Zone-B}/../{Zone-A}'
self.assertEqual(CGU.getNodeByPath(self.T, p2)[0], '{Zone-A}')
p3 = '/{Base#1}/{Zone-A}/ZoneBC'
n3 = CGU.getNodeByPath(self.T, p3)
self.assertEqual(n3[0], 'ZoneBC')
self.assertEqual(CGU.getPathFromNode(self.T, n3), p3)
c1 = '{BC-2}'
n31 = CGU.getNodeByPath(n3, c1)
self.assertEqual(n31[0], '{BC-2}')
self.assertEqual(CGU.getPathFromNode(n3, n31), "/" + c1)
c2 = './{BC-1}'
self.assertEqual(CGU.getNodeByPath(n3, c2)[0], '{BC-1}')
filter = '/.*/.*/Zone.*'
v1 = [
'/{Base#1}/{Zone-B}/ZoneBC',
'/{Base#1}/{Zone-B}/ZoneGridConnectivity'
]
self.assertEqual(CGU.getPathByNameFilter(self.T, filter)[3:5], v1)
filter = '/.*/.*/.*/GridConnectivity.*'
v2 = '/{Base#1}/{Zone-D2}/ZoneGridConnectivity/{CT-D2-C}'
self.assertEqual(CGU.getPathByTypeFilter(self.T, filter)[-2], v2)
t = CGK.CGNSBase_ts
b = CGU.getAncestorByType(self.T, n3, t)
self.assertEqual(b[3], t)
self.assertIsNone(CGU.getAncestorByType(self.T, b, CGK.Zone_ts))
t = CGK.Zone_ts
self.assertEqual(CGU.getAncestorByType(b, n3, t)[3], t)
for p in CGU.getPathsByTypeSet(self.T, [CGK.BC_ts]):
node = CGU.getNodeByPath(self.T, p)
self.assertEqual(p, CGU.getPathFromNode(self.T, node))
res = CGU.getPathsByTypeOrNameList(self.T, ['Zaza'])
self.assertEqual(res, [])
# pyCGNS.PAT - CFD General Notation System - # See license.txt file in the root directory of this Python module source # ------------------------------------------------------------------------- # from __future__ import print_function import CGNS.PAT.cgnslib as CGL import CGNS.PAT.cgnsutils as CGU T = CGL.newCGNSTree() B = CGL.newBase(T, 'Base', 3, 3) Z = CGL.newZone(B, 'Zone1') Z = CGL.newZone(B, 'Zone2') Z = CGL.newZone(B, 'Zone3') Z = CGL.newZone(B, 'Zone4') l1 = CGU.getAllNodesByTypeList(T, ['CGNSTree_t', 'CGNSBase_t', 'Zone_t']) l2 = CGU.getAllNodesByTypeSet(T, ['Zone_t', 'IndexArray_t']) print(l1) print(l2) print(CGU.getNodeByPath(l1[0], T)) l3 = CGU.getAllNodesByTypeList(B, ['CGNSBase_t', 'Zone_t']) l4 = CGU.getAllNodesByTypeSet(B, ['Zone_t']) print(l3) print(l4) print(CGU.getNodeByPath(B, l3[0]))
TESTS.append((tag, T, diag))
# -------------------------------------------------------------------------
tag = 'indexarray InwardNormalList bad shape #3'
diag = False
(T, b, z, zbc) = makeCorrectTree(vertexsize, cellsize)
n = CGL.newBoundary(zbc,
'BC', [range(1, cellsize + 1)],
btype=CGK.Null_s,
family=None,
pttype=CGK.PointList_s)
g = CGL.newGridLocation(n, value=CGK.CellCenter_s)
inl = CGL.newIndexArray(n, CGK.InwardNormalList_s, value=NPY.ones([cellsize]))
TESTS.append((tag, T, diag))
# -------------------------------------------------------------------------
tag = 'indexarray InwardNormalList bad shape #4'
diag = False
(T, b, z, zbc) = makeCorrectTree(vertexsize, cellsize)
n = CGL.newBoundary(zbc,
'BC', [range(1, cellsize + 1)],
btype=CGK.Null_s,
family=None,
pttype=CGK.PointList_s)
g = CGL.newGridLocation(n, value=CGK.CellCenter_s)
CGU.nodeDelete(T, CGU.getNodeByPath(n, 'BC/' + CGK.PointList_s))
inl = CGL.newIndexArray(n,
CGK.InwardNormalList_s,
value=NPY.ones([2, cellsize]))
TESTS.append((tag, T, diag))
#!/usr/bin/env python
from __future__ import print_function
import CGNS.MAP
import CGNS.PAT.cgnsutils as PU
import numpy
import time
import sys
numpy.set_printoptions(threshold=sys.maxint)
flags=CGNS.MAP.S2P_FOLLOWLINKS|CGNS.MAP.S2P_TRACE
start=time.clock()
(tree,links)=CGNS.MAP.load("./001Disk.hdf",flags)
node=PU.getNodeByPath(tree,"/Disk/zone1/ZoneBC/ext1/PointRange")
print("PointRange is fortran:",numpy.isfortran(node[1]),node[1],node[1].shape)
f=open('T0.py','w+')
f.write('from numpy import *\n')
f.write('tree=')
f.write(str(tree))
f.write('\nlinks=')
f.write(str(links))
f.write('\n')
f.close()
CGNS.MAP.save("./002Disk.hdf",tree,links,flags)
end=time.clock()
print('# time =',end-start)
pttype=CGK.PointRange_s)
g = CGL.newGridLocation(n, value=CGK.FaceCenter_s)
z = [z1, z2]
return (T, b, z)
(T, b, z) = makeStTree()
TESTS.append((tag, T, diag))
# -------------------------------------------------------------------------
tag = 'zone structured uncomplete BC and GridConnect (warning)'
diag = False
(T, b, z) = makeStTree()
pth = CGU.getAllNodesByTypeOrNameList(z[0],
['Zone_t', 'ZoneBC_t', '{BC1_1}'])[0]
CGU.removeChildByName(CGU.getNodeByPath(z[0], CGU.getPathAncestor(pth)),
'{BC1_1}')
pth = CGU.getAllNodesByTypeOrNameList(
z[1], ['Zone_t', 'ZoneGridConnectivity_t', 'join2_1'])[0]
CGU.removeChildByName(CGU.getNodeByPath(z[1], CGU.getPathAncestor(pth)),
'join2_1')
TESTS.append((tag, T, diag))
# -------------------------------------------------------------------------
tag = 'zone structured doubly defined BC and GridConnect (warning)'
diag = False
(T, b, z) = makeStTree()
pth = CGU.getAllNodesByTypeOrNameList(z[0], ['Zone_t', 'ZoneBC_t'])[0]
zbc = CGU.getNodeByPath(z[0], pth)
n = CGL.newBoundary(zbc,
'{BC1_1b}', [[5, 5], [1, 2], [1, 2]],
p_arr = var_mat[:,8]
# For now, skip the elem connectivity section. Because I do not need it.
##############################
# Write to CGNS file
##############################
import CGNS.PAT.cgnsutils as CGU
import CGNS.PAT.cgnslib as CGL
import CGNS.PAT.cgnskeywords as CK
import CGNS.MAP as CGM
T=CGL.newCGNSTree()
B=CGL.newBase(T,'hpMusic_base',2,2)
# The shape (3,1) is critical
zone_size = np.array([[n_node, n_elem, 0]])
Z=CGL.newZone(B,'Solution',zone_size,CK.Unstructured_s,'')
GC=CGL.newGridCoordinates(Z,name='GridCoordinates')
FS=CGL.newFlowSolution(Z,name='FlowSolution',gridlocation='Vertex')
GL=CGU.getNodeByPath(FS,'GridLocation')
CGU.nodeDelete(FS,GL)
coordinatex_node = CGL.newDataArray(GC,'CoordinateX',value=x_arr)
coordinatey_node = CGL.newDataArray(GC,'CoordinateY',value=y_arr)
density_node = CGL.newDataArray(FS,'Density',value=rho_arr)
velocityx_node = CGL.newDataArray(FS,'VelocityX',value=u_arr)
velocityy_node = CGL.newDataArray(FS,'VelocityY',value=v_arr)
p_node = CGL.newDataArray(FS,'Pressure',value=p_arr)
CGM.save("sol_tec.cgns",T)
