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)