def setUp(self): self.mesh = Mesh(name="mesh1") self.points = [ Point((0.0, 0.0, 0.0)), Point((1.0, 0.0, 0.0)), Point((1.0, 1.0, 0.0)), Point((0.0, 1.0, 0.0)), Point((0.0, 0.0, 1.0)), Point((1.0, 0.0, 1.0)), Point((1.0, 1.0, 1.0)), Point((0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add(self.faces) self.cells = [Cell(puids)] self.puids = puids self.mesh.add(self.cells)
def read_modelpart_as_mesh(self, filename): """ Reads a Kratos formated modelpart from DEM """ model_part = KRTS.ModelPart("Fluid") model_part.AddNodalSolutionStepVariable(KRTS.RADIUS) model_part.AddNodalSolutionStepVariable(KRTSDEM.PARTICLE_DENSITY) model_part.AddNodalSolutionStepVariable(KRTS.VELOCITY) model_part_io_fluid = KRTS.ModelPartIO(filename) model_part_io_fluid.ReadModelPart(model_part) smp_meshes = [] smp_conditions = [] smp_materials = [] dem_fem_pe = api.Cfd() dem_fem_pe.data[CUBA.DATA_SET] = [] for i in xrange(1, model_part.NumberOfMeshes()): mesh_name = 'solid_' + str(i) mesh = SMesh(name=mesh_name) # Export mesh data to Simphony self.exportKratosNodes(model_part, mesh, i) self.exportKratosElements(model_part, mesh, i) self.exportKratosConditions(model_part, mesh, i) properties = model_part.GetProperties(0)[i] # Fill the boundary condition for the mesh condition = self.convertBc(properties, mesh_name) # Fill the material for the mesh material = self.convertMaterial(properties, mesh_name) # Save the relations meshData = mesh.data meshData[CUBA.CONDITION] = condition.name meshData[CUBA.MATERIAL] = material.name mesh.data = meshData # Pack the return objects smp_meshes.append(mesh) smp_conditions.append(condition) smp_materials.append(material) # Add to the pe? dem_fem_pe.data[CUBA.DATA_SET].append(mesh.name) return { 'datasets': smp_meshes, 'conditions': smp_conditions, 'materials': smp_materials, 'pe': dem_fem_pe, }
def test_mesh_snapshot(self): filename = self.filename points = numpy.array([ [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [2, 0, 0], [3, 0, 0], [3, 1, 0], [2, 1, 0], [2, 0, 1], [3, 0, 1], [3, 1, 1], [2, 1, 1]], 'f') mesh = Mesh('test') point_iter = (Point(coordinates=point) for point in points) mesh.add(point_iter) snapshot(mesh, filename) self.assertImageSavedWithContent(filename)
def setUp(self): self.mesh = Mesh(name="mesh1") numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode) self.pool = NumerrinPool() self.points = [ Point( (0.0, 0.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 0.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 1.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 1.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 0.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 0.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 1.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 1.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})) ] puids = self.mesh.add_points(self.points) self.puids = puids self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add_faces(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add_cells(self.cells)
def test_mesh_show(self): points = numpy.array([ [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [2, 0, 0], [3, 0, 0], [3, 1, 0], [2, 1, 0], [2, 0, 1], [3, 0, 1], [3, 1, 1], [2, 1, 1]], 'f') mesh = Mesh('test') point_iter = (Point(coordinates=point) for point in points) mesh.add(point_iter) def function(): show(mesh) return True tester = ModalDialogTester(function) tester.open_and_run(when_opened=lambda x: x.close(accept=False)) self.assertTrue(tester.result)
def test_initialization_from_cuds(self): # given count = itertools.count() points = [ Point(coordinates=point, data=DataContainer(TEMPERATURE=index)) for index, point in enumerate(self.points)] container = Mesh('test') container.add(points) faces = [ Face( points=[points[index].uid for index in face], data=DataContainer(TEMPERATURE=next(count))) for face in self.faces] edges = [ Edge( points=[points[index].uid for index in edge], data=DataContainer(TEMPERATURE=next(count))) for edge in self.edges] cells = [ Cell( points=[points[index].uid for index in cell], data=DataContainer(TEMPERATURE=next(count))) for cell in self.cells] container.add(edges) container.add(faces) container.add(cells) # when vtk_container = VTKMesh.from_mesh(container) # then self.assertEqual(vtk_container.name, container.name) self.assertEqual(sum(1 for _ in vtk_container.iter( item_type=CUBA.POINT)), 12) self.assertEqual(sum(1 for _ in vtk_container.iter( item_type=CUBA.EDGE )), 2) self.assertEqual(sum(1 for _ in vtk_container.iter( item_type=CUBA.FACE )), 1) self.assertEqual(sum(1 for _ in vtk_container.iter( item_type=CUBA.CELL )), 2) for point in points: self.assertEqual(vtk_container.get(point.uid), point) for edge in edges: self.assertEqual(vtk_container.get(edge.uid), edge) for face in faces: self.assertEqual(vtk_container.get(face.uid), face) for cell in cells: self.assertEqual(vtk_container.get(cell.uid), cell)
def setUp(self): self.mesh = Mesh(name="mesh1") self.points = [ Point( (0.0, 0.0, 0.0)), Point( (1.0, 0.0, 0.0)), Point( (1.0, 1.0, 0.0)), Point( (0.0, 1.0, 0.0)), Point( (0.0, 0.0, 1.0)), Point( (1.0, 0.0, 1.0)), Point( (1.0, 1.0, 1.0)), Point( (0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add(self.cells)
def __init__(self, name): Mesh.__init__(self, name) self._boundaries = {}
def container_factory(self, name): return Mesh(name=name)
def setUp(self): self.mesh = Mesh(name="mesh1") numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode) self.points = [ Point( (0.0, 0.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 0.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 1.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 1.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 0.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 0.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 1.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 1.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]], data=DataContainer({CUBA.LABEL: 0})), Face([puids[1], puids[2], puids[6], puids[5]], data=DataContainer({CUBA.LABEL: 1})), Face([puids[0], puids[1], puids[5], puids[4]], data=DataContainer({CUBA.LABEL: 2})), Face([puids[3], puids[2], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 3})), Face([puids[0], puids[1], puids[2], puids[3]], data=DataContainer({CUBA.LABEL: 4})), Face([puids[4], puids[5], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 5})) ] self.edge = Edge([puids[0], puids[3]]) self.mesh.add(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add(self.cells) self.variablename = self.mesh.name + "Velocity" self.variable = tuple([(0.0, 0.0, 0.0) for _ in self.points]) self.boundaries = {} for i in range(6): self.boundaries['boundary'+str(i)] = [self.faces[i].uid]
def setUp(self): self.mesh = Mesh(name="mesh1") numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode) self.pool = NumerrinPool() self.points = [ Point((0.0, 0.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 0.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 1.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 1.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 0.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 0.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 1.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 1.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })) ] puids = self.mesh.add_points(self.points) self.puids = puids self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add_faces(self.faces) self.cells = [Cell(puids)] self.puids = puids self.mesh.add_cells(self.cells)
class FoamInterfaceTestCase(unittest.TestCase): """Test case for OpenFOAM native interface""" def setUp(self): print "Running FOAM interface test" self.name = 'mesh1' self.test_dir = 'test' self.path = os.path.join(self.test_dir, self.name) self.time = '0' self.mesh = Mesh(self.name) self.points = [ Point( (0.0, 0.0, 0.0)), Point( (1.0, 0.0, 0.0)), Point( (1.0, 1.0, 0.0)), Point( (0.0, 1.0, 0.0)), Point( (0.0, 0.0, 1.0)), Point( (1.0, 0.0, 1.0)), Point( (1.0, 1.0, 1.0)), Point( (0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add(self.cells) self._uuidToFoamLabelAndType = {} self._foamCellLabelToUuid = {} self._foamFaceLabelToUuid = {} self._foamEdgeLabelToUuid = {} self._foamPointLabelToUuid = {} # generate uuid mapping label = 0 for point in self.mesh.iter(item_type=CUBA.POINT): uid = point.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT) self._foamPointLabelToUuid[label] = uid label += 1 label = 0 for edge in self.mesh.iter(item_type=CUBA.EDGE): uid = edge.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE) self._foamEdgeLabelToUuid[label] = uid label += 1 label = 0 for face in self.mesh.iter(item_type=CUBA.FACE): uid = face.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE) self._foamFaceLabelToUuid[label] = uid label += 1 label = 0 for cell in self.mesh.iter(item_type=CUBA.CELL): uid = cell.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL) self._foamCellLabelToUuid[label] = uid label += 1 # find out boundary patches patchNameFacesMap = OrderedDict() self.facePoints = [] i = 0 for face in self.mesh.iter(item_type=CUBA.FACE): boundary = 'boundary' + str(i) i += 1 if boundary not in patchNameFacesMap: patchNameFacesMap[boundary] = [] patchNameFacesMap[boundary].append( self._uuidToFoamLabelAndType[face.uid][0]) # make compressed list of faces points self.facePoints.append(len(face.points)) for puid in face.points: self.facePoints.append(self._uuidToFoamLabelAndType[puid][0]) # make points coordinate list self.pointCoordinates = [] for point in self.mesh.iter(item_type=CUBA.POINT): for coord in point.coordinates: self.pointCoordinates.append(coord) # make compressed list of cells points self.cellPoints = [] for cell in self.mesh.iter(item_type=CUBA.CELL): self.cellPoints.append(len(cell.points)) for puid in cell.points: self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0]) # make patch information self.patchNames = [] self.patchFaces = [] for patchName in patchNameFacesMap: self.patchNames.append(patchName) self.patchFaces.append(len(patchNameFacesMap[patchName])) for face in patchNameFacesMap[patchName]: self.patchFaces.append(face) if not self.patchNames: error_str = 'Could not initialize with mesh {}. ' error_str += 'Mesh has not boundary face definitions.' raise ValueError(error_str.format(self.mesh.name)) self.patchTypes = [] for i in range(len(self.patchNames)): self.patchTypes.append("patch") # this to have controlDict file for mesh definition mapContent = foam_dicts.dictionaryMaps['pimpleFoam'] controlDict = foam_dicts.parse_map(mapContent['controlDict']) # init objectRegistry and map to mesh name foamface.init(self.name, controlDict) # add mesh to objectRegisty foamface.addMesh(self.name, self.pointCoordinates, self.cellPoints, self.facePoints, self.patchNames, self.patchFaces, self.patchTypes) foamface.createDefaultFields(self.name, 'pimpleFoam', True) def tearDown(self): if os.path.exists(self.test_dir): shutil.rmtree(self.test_dir) def test_add_mesh(self): """Test addMesh method """ pointCoordinates = foamface.getAllPointCoordinates(self.name) self.assertEqual(self.pointCoordinates, pointCoordinates) cellPoints = foamface.getAllCellPoints(self.name) self.assertEqual(set(self.cellPoints), set(cellPoints)) facePoints = foamface.getAllFacePoints(self.name) self.assertEqual(self.facePoints, facePoints) patchNames = foamface.getBoundaryPatchNames(self.name) self.assertEqual(self.patchNames, patchNames) patchFaces = foamface.getBoundaryPatchFaces(self.name) self.assertEqual(self.patchFaces, patchFaces) def test_get_point_coordinates(self): """Test getPointCoordinates method """ for point in self.points: coords = foamface.getPointCoordinates( self.name, self._uuidToFoamLabelAndType[point.uid][0]) self.assertEqual(point.coordinates, tuple(coords)) def test_get_face_points(self): """Test getFacePoints method """ for face in self.faces: pointLabels = foamface.getFacePoints( self.name, self._uuidToFoamLabelAndType[face.uid][0]) puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels] self.assertEqual(puids, face.points) def test_get_cell_points(self): """Test getCellPoints method """ for cell in self.cells: pointLabels = foamface.getCellPoints( self.name, self._uuidToFoamLabelAndType[cell.uid][0]) puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels] self.assertEqual(set(puids), set(cell.points)) def test_get_boundary_patch_names(self): """Test getBoundaryPatchNames and getBoundaryPatchFaces method """ patchNames = foamface.getBoundaryPatchNames(self.name) patchFaces = foamface.getBoundaryPatchFaces(self.name) self.assertEqual(set(patchNames), set(self.patchNames)) self.assertEqual(set(patchFaces), set(self.patchFaces)) def test_get_face_count(self): """Test getFaceCount method """ nFaces = foamface.getFaceCount(self.name) self.assertEqual(nFaces, len(self.faces)) def test_get_point_count(self): """Test getPointCount method """ nPoints = foamface.getPointCount(self.name) self.assertEqual(nPoints, len(self.points)) def test_get_cell_count(self): """Test getCellCount method """ nCells = foamface.getCellCount(self.name) self.assertEqual(nCells, len(self.cells))
def export_mesh(self, s_name, name, boundary_names): """ export Numerrin mesh from pool to SimPhoNy Mesh object Parameters ---------- s_name : str Simphony mesh name name : str name of mesh boundary_names : list str list of boundary domain names Return ------ (simphonyMesh, mmap) : tuple tuple of SimPhoNy mesh object and mapping from low level objects uuid to Numerrin label """ simphonyMesh = Mesh(s_name) uuids = [] mmap = {} meshsize = numerrin.meshsize(self.ph, name) spoints = [] for i in range(meshsize[0]): coord = numerrin.getnode(self.ph, name, i) spoint = Point(coord, uid=generate_uuid()) spoints.append(spoint) uuids.append(spoint.uid) mmap[spoint.uid] = i simphonyMesh.add(spoints) if len(meshsize) > 1: edges = [] for i in range(meshsize[1]): plbl = numerrin.getelement(self.ph, name, 1, i, 0) points = [] for pi in range(len(plbl)): points.append(uuids[plbl[pi]]) ed = Edge(points, uid=generate_uuid()) edges.append(ed) mmap[ed.uid] = i simphonyMesh.add(edges) if len(meshsize) > 2: labeluidmap = {} faces = [] for i in range(meshsize[2]): plbl = numerrin.getelement(self.ph, name, 2, i, 0) points = [] for pi in range(len(plbl)): points.append(uuids[plbl[pi]]) face_renode(points) fa = Face(points, uid=generate_uuid()) faces.append(fa) mmap[fa.uid] = i labeluidmap[i] = fa.uid simphonyMesh.add(faces) boundaries = {} for boundary in boundary_names: boundaries[boundary] = [] boundary_faces = numerrin.getelementnumbers(self.ph, name+boundary) for boundary_face in boundary_faces: boundaries[boundary].append( labeluidmap[boundary_face]) if len(meshsize) > 3: cells = [] for i in range(meshsize[3]): plbl = numerrin.getelement(self.ph, name, 3, i, 0) points = [] for pi in range(len(plbl)): points.append(uuids[plbl[pi]]) cell_renode(points) ce = Cell(points, uid=generate_uuid()) cells.append(ce) mmap[ce.uid] = i simphonyMesh.add(cells) return (simphonyMesh, mmap, boundaries)
points = array([ [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [2, 0, 0], [3, 0, 0], [3, 1, 0], [2, 1, 0], [2, 0, 1], [3, 0, 1], [3, 1, 1], [2, 1, 1]], 'f') cells = [ [0, 1, 2, 3], # tetra [4, 5, 6, 7, 8, 9, 10, 11]] # hex faces = [[2, 7, 11]] edges = [[1, 4], [3, 8]] container = Mesh('test') # add points point_iter = (Point(coordinates=point, data=DataContainer(TEMPERATURE=index)) for index, point in enumerate(points)) uids = container.add(point_iter) # add edges edge_iter = (Edge(points=[uids[index] for index in element], data=DataContainer(TEMPERATURE=index + 20)) for index, element in enumerate(edges)) edge_uids = container.add(edge_iter) # add faces face_iter = (Face(points=[uids[index] for index in element], data=DataContainer(TEMPERATURE=index + 30))
def setUp(self): self.mesh = Mesh(name="mesh1") numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode) self.points = [ Point((0.0, 0.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 0.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 1.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 1.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 0.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 0.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 1.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 1.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]], data=DataContainer({CUBA.LABEL: 0})), Face([puids[1], puids[2], puids[6], puids[5]], data=DataContainer({CUBA.LABEL: 1})), Face([puids[0], puids[1], puids[5], puids[4]], data=DataContainer({CUBA.LABEL: 2})), Face([puids[3], puids[2], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 3})), Face([puids[0], puids[1], puids[2], puids[3]], data=DataContainer({CUBA.LABEL: 4})), Face([puids[4], puids[5], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 5})) ] self.edge = Edge([puids[0], puids[3]]) self.mesh.add(self.faces) self.cells = [Cell(puids)] self.puids = puids self.mesh.add(self.cells) self.variablename = self.mesh.name + "Velocity" self.variable = tuple([(0.0, 0.0, 0.0) for _ in self.points]) self.boundaries = {} for i in range(6): self.boundaries['boundary' + str(i)] = [self.faces[i].uid]
def setUp(self): self.name = 'mesh1' self.test_dir = 'test' self.path = os.path.join(self.test_dir, self.name) self.time = '0' self.mesh = Mesh(self.name) self.points = [ Point( (0.0, 0.0, 0.0)), Point( (1.0, 0.0, 0.0)), Point( (1.0, 1.0, 0.0)), Point( (0.0, 1.0, 0.0)), Point( (0.0, 0.0, 1.0)), Point( (1.0, 0.0, 1.0)), Point( (1.0, 1.0, 1.0)), Point( (0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]], data=DataContainer({CUBA.LABEL: 0})), Face([puids[1], puids[2], puids[6], puids[5]], data=DataContainer({CUBA.LABEL: 1})), Face([puids[0], puids[1], puids[5], puids[4]], data=DataContainer({CUBA.LABEL: 2})), Face([puids[3], puids[2], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 3})), Face([puids[0], puids[1], puids[2], puids[3]], data=DataContainer({CUBA.LABEL: 4})), Face([puids[4], puids[5], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 5})) ] self.mesh.add(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add(self.cells) self._uuidToFoamLabelAndType = {} self._foamCellLabelToUuid = {} self._foamFaceLabelToUuid = {} self._foamEdgeLabelToUuid = {} self._foamPointLabelToUuid = {} # generate uuid mapping label = 0 for point in self.mesh.iter(item_type=CUBA.POINT): uid = point.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT) self._foamPointLabelToUuid[label] = uid label += 1 label = 0 for edge in self.mesh.iter(item_type=CUBA.EDGE): uid = edge.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE) self._foamEdgeLabelToUuid[label] = uid label += 1 label = 0 for face in self.mesh.iter(item_type=CUBA.FACE): uid = face.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE) self._foamFaceLabelToUuid[label] = uid label += 1 label = 0 for cell in self.mesh.iter(item_type=CUBA.CELL): uid = cell.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL) self._foamCellLabelToUuid[label] = uid label += 1 # find out boundary patches patchNameFacesMap = OrderedDict() self.facePoints = [] i = 0 for face in self.mesh.iter(item_type=CUBA.FACE): boundary = 'boundary' + str(i) i += 1 if boundary not in patchNameFacesMap: patchNameFacesMap[boundary] = [] patchNameFacesMap[boundary].append( self._uuidToFoamLabelAndType[face.uid][0]) # make compressed list of faces points self.facePoints.append(len(face.points)) for puid in face.points: self.facePoints.append( self._uuidToFoamLabelAndType[puid][0]) # make points coordinate list self.pointCoordinates = [] for point in self.mesh.iter(item_type=CUBA.POINT): for coord in point.coordinates: self.pointCoordinates.append(coord) # make compressed list of cells points self.cellPoints = [] for cell in self.mesh.iter(item_type=CUBA.CELL): self.cellPoints.append(len(cell.points)) for puid in cell.points: self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0]) # make patch information self.patchNames = [] self.patchFaces = [] self.patchTypes = [] for patchName in patchNameFacesMap: self.patchNames.append(patchName) self.patchFaces.append(len(patchNameFacesMap[patchName])) for face in patchNameFacesMap[patchName]: self.patchFaces.append(face) self.patchTypes.append("patch") if not self.patchNames: error_str = 'Could not initialize with mesh {}. ' error_str += 'Mesh has not boundary face definitions.' raise ValueError(error_str.format(self.mesh.name)) # this to have controlDict file for mesh definition mapContent = get_dictionary_maps('simpleFoam', False) controlDict = parse_map(mapContent['controlDict']) foamface.init_IO(self.name, os.path.abspath(os.path.join(self.path, os.pardir)), controlDict) foamface.addMesh(self.name, self.pointCoordinates, self.cellPoints, self.facePoints, self.patchNames, self.patchFaces, self.patchTypes)
class WrapperTestCase(unittest.TestCase): """Test case for Wrapper class""" def setUp(self): self.mesh = Mesh(name="mesh1") self.points = [ Point( (0.0, 0.0, 0.0)), Point( (1.0, 0.0, 0.0)), Point( (1.0, 1.0, 0.0)), Point( (0.0, 1.0, 0.0)), Point( (0.0, 0.0, 1.0)), Point( (1.0, 0.0, 1.0)), Point( (1.0, 1.0, 1.0)), Point( (0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add(self.cells) def test_add_dataset(self): """Test add_dataset method """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 1) def test_remove_dataset(self): """Test remove_dataset method """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) wrapper.remove_dataset(self.mesh.name) with self.assertRaises(KeyError): wrapper.get_dataset(self.mesh.name) def test_get_dataset(self): """Test get_dataset method """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) mesh_inside_wrapper = wrapper.get_dataset(self.mesh.name) self.assertEqual(self.mesh.name, mesh_inside_wrapper.name) for point in self.mesh.iter(item_type=CUBA.POINT): point_w = mesh_inside_wrapper._get_point(point.uid) self.assertEqual(point.coordinates, point_w.coordinates) for face in self.mesh.iter(item_type=CUBA.FACE): face_w = mesh_inside_wrapper._get_face(face.uid) self.assertEqual(face.points, face_w.points) for cell in self.mesh.iter(item_type=CUBA.CELL): cell_w = mesh_inside_wrapper._get_cell(cell.uid) self.assertEqual(set(cell.points), set(cell_w.points)) def test_iter_datasets(self): """Test iter_datsets method """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) mesh2 = self.mesh mesh2.name = "mesh2" wrapper.add_dataset(mesh2) self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 2) def test_multiple_meshes(self): """Test multiple meshes inside wrapper """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) mesh2 = self.mesh mesh2.name = "mesh2" wrapper.add_dataset(mesh2) mesh_inside_wrapper1 = wrapper.get_dataset(self.mesh.name) mesh_inside_wrapper2 = wrapper.get_dataset(mesh2.name) self.assertEqual( sum(1 for _ in mesh_inside_wrapper1.iter(item_type=CUBA.POINT)), sum(1 for _ in mesh_inside_wrapper2.iter(item_type=CUBA.POINT))) def test_run_time(self): """Test that field variable value is changed after consecutive calls of run method """ wrapper = Wrapper() name = 'simplemesh' corner_points = ((0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)) extrude_length = 1 nex = 3 ney = 3 nez = 1 create_quad_mesh(name, wrapper, corner_points, extrude_length, nex, ney, nez) wrapper.CM[CUBA.NAME] = name wrapper.CM_extensions[CUBAExt.GE] = (CUBAExt.INCOMPRESSIBLE, CUBAExt.LAMINAR_MODEL) wrapper.SP[CUBA.TIME_STEP] = 1 wrapper.SP[CUBA.NUMBER_OF_TIME_STEPS] = 1 wrapper.SP[CUBA.DENSITY] = 1.0 wrapper.SP[CUBA.DYNAMIC_VISCOSITY] = 1.0 wrapper.BC[CUBA.VELOCITY] = {'inflow': ('fixedValue', (0.1, 0, 0)), 'outflow': 'zeroGradient', 'walls': ('fixedValue', (0, 0, 0)), 'frontAndBack': 'empty'} wrapper.BC[CUBA.PRESSURE] = {'inflow': 'zeroGradient', 'outflow': ('fixedValue', 0), 'walls': 'zeroGradient', 'frontAndBack': 'empty'} mesh_inside_wrapper = wrapper.get_dataset(name) wrapper.run() # sum data pointwise old_vel = 0.0 old_pres = 0.0 for point in mesh_inside_wrapper.iter(item_type=CUBA.POINT): velo = point.data[CUBA.VELOCITY] old_vel += math.sqrt(velo[0]*velo[0] + velo[1]*velo[1] + velo[2]*velo[2]) old_pres += point.data[CUBA.PRESSURE] wrapper.SP[CUBA.DENSITY] = 5.0 wrapper.run() # sum data pointwise new_vel = 0.0 new_pres = 0.0 for point in mesh_inside_wrapper.iter(item_type=CUBA.POINT): velo = point.data[CUBA.VELOCITY] new_vel += math.sqrt(velo[0]*velo[0] + velo[1]*velo[1] + velo[2]*velo[2]) new_pres += point.data[CUBA.PRESSURE] self.assertNotAlmostEqual(old_vel, new_vel, 5) self.assertNotAlmostEqual(old_pres, new_pres, 5)
def export_mesh(self, s_name, name, boundary_names): """ export Numerrin mesh from pool to SimPhoNy Mesh object Parameters ---------- s_name : str Simphony mesh name name : str name of mesh boundary_names : list str list of boundary domain names Return ------ (simphonyMesh, mmap) : tuple tuple of SimPhoNy mesh object and mapping from low level objects uuid to Numerrin label """ simphonyMesh = Mesh(s_name) uuids = [] mmap = {} meshsize = numerrin.meshsize(self.ph, name) spoints = [] for i in range(meshsize[0]): coord = numerrin.getnode(self.ph, name, i) spoint = Point(coord, uid=generate_uuid()) spoints.append(spoint) uuids.append(spoint.uid) mmap[spoint.uid] = i simphonyMesh.add(spoints) if len(meshsize) > 1: edges = [] for i in range(meshsize[1]): plbl = numerrin.getelement(self.ph, name, 1, i, 0) points = [] for pi in range(len(plbl)): points.append(uuids[plbl[pi]]) ed = Edge(points, uid=generate_uuid()) edges.append(ed) mmap[ed.uid] = i simphonyMesh.add(edges) if len(meshsize) > 2: labeluidmap = {} faces = [] for i in range(meshsize[2]): plbl = numerrin.getelement(self.ph, name, 2, i, 0) points = [] for pi in range(len(plbl)): points.append(uuids[plbl[pi]]) face_renode(points) fa = Face(points, uid=generate_uuid()) faces.append(fa) mmap[fa.uid] = i labeluidmap[i] = fa.uid simphonyMesh.add(faces) boundaries = {} for boundary in boundary_names: boundaries[boundary] = [] boundary_faces = numerrin.getelementnumbers( self.ph, name + boundary) for boundary_face in boundary_faces: boundaries[boundary].append(labeluidmap[boundary_face]) if len(meshsize) > 3: cells = [] for i in range(meshsize[3]): plbl = numerrin.getelement(self.ph, name, 3, i, 0) points = [] for pi in range(len(plbl)): points.append(uuids[plbl[pi]]) cell_renode(points) ce = Cell(points, uid=generate_uuid()) cells.append(ce) mmap[ce.uid] = i simphonyMesh.add(cells) return (simphonyMesh, mmap, boundaries)
def setUp(self): self.name = 'mesh1' self.test_dir = 'test' self.path = os.path.join(self.test_dir, self.name) self.time = '0' self.mesh = Mesh(self.name) self.points = [ Point((0.0, 0.0, 0.0)), Point((1.0, 0.0, 0.0)), Point((1.0, 1.0, 0.0)), Point((0.0, 1.0, 0.0)), Point((0.0, 0.0, 1.0)), Point((1.0, 0.0, 1.0)), Point((1.0, 1.0, 1.0)), Point((0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]], data=DataContainer({CUBA.LABEL: 0})), Face([puids[1], puids[2], puids[6], puids[5]], data=DataContainer({CUBA.LABEL: 1})), Face([puids[0], puids[1], puids[5], puids[4]], data=DataContainer({CUBA.LABEL: 2})), Face([puids[3], puids[2], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 3})), Face([puids[0], puids[1], puids[2], puids[3]], data=DataContainer({CUBA.LABEL: 4})), Face([puids[4], puids[5], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 5})) ] self.mesh.add(self.faces) self.cells = [Cell(puids)] self.puids = puids self.mesh.add(self.cells) self._uuidToFoamLabelAndType = {} self._foamCellLabelToUuid = {} self._foamFaceLabelToUuid = {} self._foamEdgeLabelToUuid = {} self._foamPointLabelToUuid = {} # generate uuid mapping label = 0 for point in self.mesh.iter(item_type=CUBA.POINT): uid = point.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT) self._foamPointLabelToUuid[label] = uid label += 1 label = 0 for edge in self.mesh.iter(item_type=CUBA.EDGE): uid = edge.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE) self._foamEdgeLabelToUuid[label] = uid label += 1 label = 0 for face in self.mesh.iter(item_type=CUBA.FACE): uid = face.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE) self._foamFaceLabelToUuid[label] = uid label += 1 label = 0 for cell in self.mesh.iter(item_type=CUBA.CELL): uid = cell.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL) self._foamCellLabelToUuid[label] = uid label += 1 # find out boundary patches patchNameFacesMap = OrderedDict() self.facePoints = [] i = 0 for face in self.mesh.iter(item_type=CUBA.FACE): boundary = 'boundary' + str(i) i += 1 if boundary not in patchNameFacesMap: patchNameFacesMap[boundary] = [] patchNameFacesMap[boundary].append( self._uuidToFoamLabelAndType[face.uid][0]) # make compressed list of faces points self.facePoints.append(len(face.points)) for puid in face.points: self.facePoints.append(self._uuidToFoamLabelAndType[puid][0]) # make points coordinate list self.pointCoordinates = [] for point in self.mesh.iter(item_type=CUBA.POINT): for coord in point.coordinates: self.pointCoordinates.append(coord) # make compressed list of cells points self.cellPoints = [] for cell in self.mesh.iter(item_type=CUBA.CELL): self.cellPoints.append(len(cell.points)) for puid in cell.points: self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0]) # make patch information self.patchNames = [] self.patchFaces = [] self.patchTypes = [] for patchName in patchNameFacesMap: self.patchNames.append(patchName) self.patchFaces.append(len(patchNameFacesMap[patchName])) for face in patchNameFacesMap[patchName]: self.patchFaces.append(face) self.patchTypes.append("patch") if not self.patchNames: error_str = 'Could not initialize with mesh {}. ' error_str += 'Mesh has not boundary face definitions.' raise ValueError(error_str.format(self.mesh.name)) # this to have controlDict file for mesh definition mapContent = get_dictionary_maps('simpleFoam', False) controlDict = parse_map(mapContent['controlDict']) foamface.init_IO(self.name, os.path.abspath(os.path.join(self.path, os.pardir)), controlDict) foamface.addMesh(self.name, self.pointCoordinates, self.cellPoints, self.facePoints, self.patchNames, self.patchFaces, self.patchTypes)
class FoamInterfaceTestCase(unittest.TestCase): """Test case for OpenFOAM native interface""" def setUp(self): self.name = 'mesh1' self.test_dir = 'test' self.path = os.path.join(self.test_dir, self.name) self.time = '0' self.mesh = Mesh(self.name) self.points = [ Point((0.0, 0.0, 0.0)), Point((1.0, 0.0, 0.0)), Point((1.0, 1.0, 0.0)), Point((0.0, 1.0, 0.0)), Point((0.0, 0.0, 1.0)), Point((1.0, 0.0, 1.0)), Point((1.0, 1.0, 1.0)), Point((0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]], data=DataContainer({CUBA.LABEL: 0})), Face([puids[1], puids[2], puids[6], puids[5]], data=DataContainer({CUBA.LABEL: 1})), Face([puids[0], puids[1], puids[5], puids[4]], data=DataContainer({CUBA.LABEL: 2})), Face([puids[3], puids[2], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 3})), Face([puids[0], puids[1], puids[2], puids[3]], data=DataContainer({CUBA.LABEL: 4})), Face([puids[4], puids[5], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 5})) ] self.mesh.add(self.faces) self.cells = [Cell(puids)] self.puids = puids self.mesh.add(self.cells) self._uuidToFoamLabelAndType = {} self._foamCellLabelToUuid = {} self._foamFaceLabelToUuid = {} self._foamEdgeLabelToUuid = {} self._foamPointLabelToUuid = {} # generate uuid mapping label = 0 for point in self.mesh.iter(item_type=CUBA.POINT): uid = point.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT) self._foamPointLabelToUuid[label] = uid label += 1 label = 0 for edge in self.mesh.iter(item_type=CUBA.EDGE): uid = edge.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE) self._foamEdgeLabelToUuid[label] = uid label += 1 label = 0 for face in self.mesh.iter(item_type=CUBA.FACE): uid = face.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE) self._foamFaceLabelToUuid[label] = uid label += 1 label = 0 for cell in self.mesh.iter(item_type=CUBA.CELL): uid = cell.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL) self._foamCellLabelToUuid[label] = uid label += 1 # find out boundary patches patchNameFacesMap = OrderedDict() self.facePoints = [] i = 0 for face in self.mesh.iter(item_type=CUBA.FACE): boundary = 'boundary' + str(i) i += 1 if boundary not in patchNameFacesMap: patchNameFacesMap[boundary] = [] patchNameFacesMap[boundary].append( self._uuidToFoamLabelAndType[face.uid][0]) # make compressed list of faces points self.facePoints.append(len(face.points)) for puid in face.points: self.facePoints.append(self._uuidToFoamLabelAndType[puid][0]) # make points coordinate list self.pointCoordinates = [] for point in self.mesh.iter(item_type=CUBA.POINT): for coord in point.coordinates: self.pointCoordinates.append(coord) # make compressed list of cells points self.cellPoints = [] for cell in self.mesh.iter(item_type=CUBA.CELL): self.cellPoints.append(len(cell.points)) for puid in cell.points: self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0]) # make patch information self.patchNames = [] self.patchFaces = [] self.patchTypes = [] for patchName in patchNameFacesMap: self.patchNames.append(patchName) self.patchFaces.append(len(patchNameFacesMap[patchName])) for face in patchNameFacesMap[patchName]: self.patchFaces.append(face) self.patchTypes.append("patch") if not self.patchNames: error_str = 'Could not initialize with mesh {}. ' error_str += 'Mesh has not boundary face definitions.' raise ValueError(error_str.format(self.mesh.name)) # this to have controlDict file for mesh definition mapContent = get_dictionary_maps('simpleFoam', False) controlDict = parse_map(mapContent['controlDict']) foamface.init_IO(self.name, os.path.abspath(os.path.join(self.path, os.pardir)), controlDict) foamface.addMesh(self.name, self.pointCoordinates, self.cellPoints, self.facePoints, self.patchNames, self.patchFaces, self.patchTypes) def tearDown(self): if os.path.exists(self.test_dir): shutil.rmtree(self.test_dir) def test_add_mesh(self): """Test addMesh method """ pointCoordinates = foamface.getAllPointCoordinates(self.name) self.assertEqual(self.pointCoordinates, pointCoordinates) cellPoints = foamface.getAllCellPoints(self.name) self.assertEqual(set(self.cellPoints), set(cellPoints)) facePoints = foamface.getAllFacePoints(self.name) self.assertEqual(self.facePoints, facePoints) patchNames = foamface.getBoundaryPatchNames(self.name) self.assertEqual(self.patchNames, patchNames) patchFaces = foamface.getBoundaryPatchFaces(self.name) self.assertEqual(self.patchFaces, patchFaces) def test_write_mesh(self): """Test writeMesh method """ foamface.writeMesh(self.name) meshpath = os.path.join(self.test_dir, self.name, 'constant', 'polyMesh') self.assertTrue(os.path.exists(os.path.join(meshpath, 'points'))) self.assertTrue(os.path.exists(os.path.join(meshpath, 'owner'))) self.assertTrue(os.path.exists(os.path.join(meshpath, 'neighbour'))) self.assertTrue(os.path.exists(os.path.join(meshpath, 'boundary'))) self.assertTrue(os.path.exists(os.path.join(meshpath, 'faces'))) def test_get_point_coordinates(self): """Test getPointCoordinates method """ for point in self.points: coords = foamface.getPointCoordinates( self.name, self._uuidToFoamLabelAndType[point.uid][0]) self.assertEqual(point.coordinates, tuple(coords)) def test_get_face_points(self): """Test getFacePoints method """ for face in self.faces: pointLabels = foamface.getFacePoints( self.name, self._uuidToFoamLabelAndType[face.uid][0]) puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels] self.assertEqual(puids, face.points) def test_get_cell_points(self): """Test getCellPoints method """ for cell in self.cells: pointLabels = foamface.getCellPoints( self.name, self._uuidToFoamLabelAndType[cell.uid][0]) puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels] self.assertEqual(set(puids), set(cell.points)) def test_get_boundary_patch_names(self): """Test getBoundaryPatchNames and getBoundaryPatchFaces method """ patchNames = foamface.getBoundaryPatchNames(self.name) patchFaces = foamface.getBoundaryPatchFaces(self.name) self.assertEqual(set(patchNames), set(self.patchNames)) self.assertEqual(set(patchFaces), set(self.patchFaces)) def test_get_face_count(self): """Test getFaceCount method """ nFaces = foamface.getFaceCount(self.name) self.assertEqual(nFaces, len(self.faces)) def test_get_point_count(self): """Test getPointCount method """ nPoints = foamface.getPointCount(self.name) self.assertEqual(nPoints, len(self.points)) def test_get_cell_count(self): """Test getCellCount method """ nCells = foamface.getCellCount(self.name) self.assertEqual(nCells, len(self.cells))
class NumerrinMeshTestCase(unittest.TestCase): """Test case for NumerrinMesh class""" def setUp(self): self.mesh = Mesh(name="mesh1") numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode) self.pool = NumerrinPool() self.points = [ Point( (0.0, 0.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 0.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 1.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 1.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 0.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 0.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 1.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 1.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})) ] puids = self.mesh.add_points(self.points) self.puids = puids self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add_faces(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add_cells(self.cells) def test_get_point(self): """Test get_point method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) point = self.points[4] point_f = num_mesh.get(point.uid) self.assertEqual(point.coordinates, point_f.coordinates) self.assertEqual(point.data[CUBA.PRESSURE], point_f.data[CUBA.PRESSURE]) self.assertEqual(point.data[CUBA.VELOCITY], point_f.data[CUBA.VELOCITY]) def test_get_edge(self): """Test get_edge method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) uid = num_mesh._numEdgeLabelToUuid[0] edge = num_mesh.get(uid) self.assertEqual(edge.uid, uid) def test_get_face(self): """Test get_face method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) face = self.faces[4] face_f = num_mesh.get(face.uid) self.assertEqual(face.points, face_f.points) def test_get_cell(self): """Test get_cell method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) cell = self.cells[0] cell_f = num_mesh.get(cell.uid) self.assertEqual(set(cell.points), set(cell_f.points)) def test_add_points(self): """Test add_points method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.add(self.points) def test_add_edges(self): """Test add_edges method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.add([Edge([self.puids[0], self.puids[3]])]) def test_add_faces(self): """Test add_faces method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.add(self.faces) def test_add_cells(self): """Test add_cells method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.add(self.cells) def test_update_points(self): """Test update_points method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) points = self.points points[0].data[CUBA.VELOCITY] = (2, 1, 3) num_mesh.update(points) point_f = num_mesh.get(points[0].uid) self.assertIsInstance(point_f.data, DataContainer) self.assertEqual(points[0].data, point_f.data) def test_update_edges(self): """Test update_edges method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.update([Edge([self.puids, self.puids[3]])]) def test_update_faces(self): """Test update_faces method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.update(self.faces) def test_iter_edges(self): """Test iter_edges method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) self.assertEqual(sum(1 for _ in num_mesh.iter(item_type=CUBA.EDGE)), num_mesh.count_of(CUBA.EDGE)) def test_iter_faces(self): """Test iter_faces method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) for face_f in num_mesh.iter(item_type=CUBA.FACE): face = self.mesh.get(face_f.uid) self.assertEqual(face.points, face_f.points) def test_iter_points(self): """Test iter_points method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) for point_f in num_mesh.iter(item_type=CUBA.POINT): point = self.mesh.get(point_f.uid) self.assertEqual(point.data[CUBA.VELOCITY], point_f.data[CUBA.VELOCITY]) self.assertEqual(point.data[CUBA.PRESSURE], point_f.data[CUBA.PRESSURE]) def test_has_faces(self): """Test has_faces method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) self.assertTrue(num_mesh.has_type(CUBA.FACE)) def test_has_cells(self): """Test has_cells method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) self.assertTrue(num_mesh.has_type(CUBA.CELL)) def test_count_of(self): """Test count_of method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) item_type = CUBA.POINT self.assertEqual(num_mesh.count_of(item_type), self.mesh.count_of(item_type)) item_type = CUBA.EDGE self.assertEqual(num_mesh.count_of(item_type), 12) item_type = CUBA.FACE self.assertEqual(num_mesh.count_of(item_type), self.mesh.count_of(item_type)) item_type = CUBA.CELL self.assertEqual(num_mesh.count_of(item_type), self.mesh.count_of(item_type))
def test_compare_mesh_datasets_not_equal(self): # given mesh = Mesh(name="test") reference = Mesh(name="test_ref") point_list = create_points_with_id() edge_list = create_edges() face_list = create_faces() cell_list = create_cells() data = create_data_container() mesh.add(point_list) mesh.add(edge_list) mesh.add(face_list) mesh.add(cell_list) reference.add(point_list) reference.add(edge_list) reference.add(face_list) reference.add(cell_list) mesh.data = data reference.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_points = create_points_with_id() mesh = Mesh(name=reference.name) mesh.add(test_points) mesh.add(edge_list) mesh.add(face_list) mesh.add(cell_list) mesh.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_edges = create_edges() mesh = Mesh(name=reference.name) mesh.add(point_list) mesh.add(test_edges) mesh.add(face_list) mesh.add(cell_list) mesh.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_faces = create_faces() mesh = Mesh(name=reference.name) mesh.add(point_list) mesh.add(edge_list) mesh.add(test_faces) mesh.add(cell_list) mesh.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_cells = create_cells() mesh = Mesh(name=reference.name) mesh.add(point_list) mesh.add(edge_list) mesh.add(face_list) mesh.add(test_cells) mesh.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_data = DataContainer() mesh = Mesh(name=reference.name) mesh.add(point_list) mesh.add(edge_list) mesh.add(face_list) mesh.add(cell_list) mesh.data = test_data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self)
class NumerrinPoolTestCase(unittest.TestCase): """Test case for NumerrinPool class""" def setUp(self): self.mesh = Mesh(name="mesh1") numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode) self.points = [ Point( (0.0, 0.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 0.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 1.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 1.0, 0.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 0.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 0.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (1.0, 1.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})), Point( (0.0, 1.0, 1.0), data=DataContainer({CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0})) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]], data=DataContainer({CUBA.LABEL: 0})), Face([puids[1], puids[2], puids[6], puids[5]], data=DataContainer({CUBA.LABEL: 1})), Face([puids[0], puids[1], puids[5], puids[4]], data=DataContainer({CUBA.LABEL: 2})), Face([puids[3], puids[2], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 3})), Face([puids[0], puids[1], puids[2], puids[3]], data=DataContainer({CUBA.LABEL: 4})), Face([puids[4], puids[5], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 5})) ] self.edge = Edge([puids[0], puids[3]]) self.mesh.add(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add(self.cells) self.variablename = self.mesh.name + "Velocity" self.variable = tuple([(0.0, 0.0, 0.0) for _ in self.points]) self.boundaries = {} for i in range(6): self.boundaries['boundary'+str(i)] = [self.faces[i].uid] def test_import_mesh(self): """Test import_mesh method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) self.assertEqual(numerrin.meshsize(pool.ph, self.mesh.name)[0], len(self.points)) self.assertEqual(numerrin.meshsize(pool.ph, self.mesh.name)[2], len(self.faces)) self.assertEqual(numerrin.meshsize(pool.ph, self.mesh.name)[3], len(self.cells)) def test_clear(self): """Test clear method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) pool.clear() with self.assertRaises(RuntimeError): numerrin.meshsize(pool.ph, self.mesh.name) def test_variable_type(self): """Test variable_type method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) self.assertEqual(pool.variable_type(self.mesh.name), "Mesh") def test_variable_rank(self): """Test variable_rank method """ pool = NumerrinPool() pool.put_variable(self.variablename, self.variable) self.assertEqual(pool.variable_rank(self.variablename), 2) def test_get_variable(self): """Test get_variable method """ pool = NumerrinPool() pool.put_variable(self.variablename, self.variable) self.assertEqual(pool.get_variable(self.variablename), self.variable) def test_put_variable(self): """Test put_variable method """ pool = NumerrinPool() pool.put_variable(self.variablename, self.variable) self.assertEqual(pool.get_variable(self.variablename), self.variable) def test_modify_variable(self): """Test modify_variable method """ pool = NumerrinPool() pool.put_variable(self.variablename, self.variable) oldvar = pool.get_variable(self.variablename) modvar = tuple([(10.0, 10.0, 10.0) for _ in oldvar]) pool.modify_variable(self.variablename, modvar) newvar = pool.get_variable(self.variablename) self.assertNotEqual(oldvar, newvar) def test_delete_mesh_and_variables(self): """Test delete_mesh_and_variables method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) pool.put_variable(self.variablename, self.variable) pool.delete_mesh_and_variables(self.mesh.name) with self.assertRaises(RuntimeError): pool.get_variable(self.variablename) with self.assertRaises(RuntimeError): numerrin.meshsize(pool.ph, self.mesh.name) def test_export_mesh(self): """Test export_mesh method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) boundary_names = self.boundaries.keys() (smesh, mmap, boundaries) = pool.export_mesh(self.mesh.name, self.mesh.name, boundary_names) self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.POINT)), sum(1 for _ in self.mesh.iter(item_type=CUBA.POINT))) self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.FACE)), sum(1 for _ in self.mesh.iter(item_type=CUBA.FACE))) self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.CELL)), sum(1 for _ in self.mesh.iter(item_type=CUBA.CELL))) self.assertEqual(set([p.coordinates for p in smesh.iter(item_type=CUBA.POINT)]), set([p.coordinates for p in self.mesh.iter(item_type=CUBA.POINT)])) self.assertEqual(boundaries.keys(), boundary_names)
def test_compare_mesh_datasets_equal(self): # given mesh = Mesh(name="test") reference = Mesh(name="test") point_list = create_particles_with_id() edge_list = create_edges() face_list = create_faces() cell_list = create_cells() data = DataContainer() mesh.add_points(point_list) mesh.add_edges(edge_list) mesh.add_faces(face_list) mesh.add_cells(cell_list) reference.add_points(point_list) reference.add_edges(edge_list) reference.add_faces(face_list) reference.add_cells(cell_list) mesh.data = data reference.data = data # this should pass without problems compare_mesh_datasets(mesh, reference, testcase=self)
class FoamInterfaceTestCase(unittest.TestCase): """Test case for OpenFOAM native interface""" def setUp(self): self.name = 'mesh1' self.test_dir = 'test' self.path = os.path.join(self.test_dir, self.name) self.time = '0' self.mesh = Mesh(self.name) self.points = [ Point( (0.0, 0.0, 0.0)), Point( (1.0, 0.0, 0.0)), Point( (1.0, 1.0, 0.0)), Point( (0.0, 1.0, 0.0)), Point( (0.0, 0.0, 1.0)), Point( (1.0, 0.0, 1.0)), Point( (1.0, 1.0, 1.0)), Point( (0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]], data=DataContainer({CUBA.LABEL: 0})), Face([puids[1], puids[2], puids[6], puids[5]], data=DataContainer({CUBA.LABEL: 1})), Face([puids[0], puids[1], puids[5], puids[4]], data=DataContainer({CUBA.LABEL: 2})), Face([puids[3], puids[2], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 3})), Face([puids[0], puids[1], puids[2], puids[3]], data=DataContainer({CUBA.LABEL: 4})), Face([puids[4], puids[5], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 5})) ] self.mesh.add(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add(self.cells) self._uuidToFoamLabelAndType = {} self._foamCellLabelToUuid = {} self._foamFaceLabelToUuid = {} self._foamEdgeLabelToUuid = {} self._foamPointLabelToUuid = {} # generate uuid mapping label = 0 for point in self.mesh.iter(item_type=CUBA.POINT): uid = point.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT) self._foamPointLabelToUuid[label] = uid label += 1 label = 0 for edge in self.mesh.iter(item_type=CUBA.EDGE): uid = edge.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE) self._foamEdgeLabelToUuid[label] = uid label += 1 label = 0 for face in self.mesh.iter(item_type=CUBA.FACE): uid = face.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE) self._foamFaceLabelToUuid[label] = uid label += 1 label = 0 for cell in self.mesh.iter(item_type=CUBA.CELL): uid = cell.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL) self._foamCellLabelToUuid[label] = uid label += 1 # find out boundary patches patchNameFacesMap = OrderedDict() self.facePoints = [] i = 0 for face in self.mesh.iter(item_type=CUBA.FACE): boundary = 'boundary' + str(i) i += 1 if boundary not in patchNameFacesMap: patchNameFacesMap[boundary] = [] patchNameFacesMap[boundary].append( self._uuidToFoamLabelAndType[face.uid][0]) # make compressed list of faces points self.facePoints.append(len(face.points)) for puid in face.points: self.facePoints.append( self._uuidToFoamLabelAndType[puid][0]) # make points coordinate list self.pointCoordinates = [] for point in self.mesh.iter(item_type=CUBA.POINT): for coord in point.coordinates: self.pointCoordinates.append(coord) # make compressed list of cells points self.cellPoints = [] for cell in self.mesh.iter(item_type=CUBA.CELL): self.cellPoints.append(len(cell.points)) for puid in cell.points: self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0]) # make patch information self.patchNames = [] self.patchFaces = [] self.patchTypes = [] for patchName in patchNameFacesMap: self.patchNames.append(patchName) self.patchFaces.append(len(patchNameFacesMap[patchName])) for face in patchNameFacesMap[patchName]: self.patchFaces.append(face) self.patchTypes.append("patch") if not self.patchNames: error_str = 'Could not initialize with mesh {}. ' error_str += 'Mesh has not boundary face definitions.' raise ValueError(error_str.format(self.mesh.name)) # this to have controlDict file for mesh definition mapContent = get_dictionary_maps('simpleFoam', False) controlDict = parse_map(mapContent['controlDict']) foamface.init_IO(self.name, os.path.abspath(os.path.join(self.path, os.pardir)), controlDict) foamface.addMesh(self.name, self.pointCoordinates, self.cellPoints, self.facePoints, self.patchNames, self.patchFaces, self.patchTypes) def tearDown(self): if os.path.exists(self.test_dir): shutil.rmtree(self.test_dir) def test_add_mesh(self): """Test addMesh method """ pointCoordinates = foamface.getAllPointCoordinates(self.name) self.assertEqual(self.pointCoordinates, pointCoordinates) cellPoints = foamface.getAllCellPoints(self.name) self.assertEqual(set(self.cellPoints), set(cellPoints)) facePoints = foamface.getAllFacePoints(self.name) self.assertEqual(self.facePoints, facePoints) patchNames = foamface.getBoundaryPatchNames(self.name) self.assertEqual(self.patchNames, patchNames) patchFaces = foamface.getBoundaryPatchFaces(self.name) self.assertEqual(self.patchFaces, patchFaces) def test_write_mesh(self): """Test writeMesh method """ foamface.writeMesh(self.name) meshpath = os.path.join(self.test_dir, self.name, 'constant', 'polyMesh') self.assertTrue(os.path.exists(os.path.join(meshpath, 'points'))) self.assertTrue(os.path.exists(os.path.join(meshpath, 'owner'))) self.assertTrue(os.path.exists(os.path.join(meshpath, 'neighbour'))) self.assertTrue(os.path.exists(os.path.join(meshpath, 'boundary'))) self.assertTrue(os.path.exists(os.path.join(meshpath, 'faces'))) def test_get_point_coordinates(self): """Test getPointCoordinates method """ for point in self.points: coords = foamface.getPointCoordinates( self.name, self._uuidToFoamLabelAndType[point.uid][0]) self.assertEqual(point.coordinates, tuple(coords)) def test_get_face_points(self): """Test getFacePoints method """ for face in self.faces: pointLabels = foamface.getFacePoints( self.name, self._uuidToFoamLabelAndType[face.uid][0]) puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels] self.assertEqual(puids, face.points) def test_get_cell_points(self): """Test getCellPoints method """ for cell in self.cells: pointLabels = foamface.getCellPoints( self.name, self._uuidToFoamLabelAndType[cell.uid][0]) puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels] self.assertEqual(set(puids), set(cell.points)) def test_get_boundary_patch_names(self): """Test getBoundaryPatchNames and getBoundaryPatchFaces method """ patchNames = foamface.getBoundaryPatchNames(self.name) patchFaces = foamface.getBoundaryPatchFaces(self.name) self.assertEqual(set(patchNames), set(self.patchNames)) self.assertEqual(set(patchFaces), set(self.patchFaces)) def test_get_face_count(self): """Test getFaceCount method """ nFaces = foamface.getFaceCount(self.name) self.assertEqual(nFaces, len(self.faces)) def test_get_point_count(self): """Test getPointCount method """ nPoints = foamface.getPointCount(self.name) self.assertEqual(nPoints, len(self.points)) def test_get_cell_count(self): """Test getCellCount method """ nCells = foamface.getCellCount(self.name) self.assertEqual(nCells, len(self.cells))
def setUp(self): print "Running FOAM interface test" self.name = 'mesh1' self.test_dir = 'test' self.path = os.path.join(self.test_dir, self.name) self.time = '0' self.mesh = Mesh(self.name) self.points = [ Point( (0.0, 0.0, 0.0)), Point( (1.0, 0.0, 0.0)), Point( (1.0, 1.0, 0.0)), Point( (0.0, 1.0, 0.0)), Point( (0.0, 0.0, 1.0)), Point( (1.0, 0.0, 1.0)), Point( (1.0, 1.0, 1.0)), Point( (0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add(self.faces) self.cells = [ Cell(puids) ] self.puids = puids self.mesh.add(self.cells) self._uuidToFoamLabelAndType = {} self._foamCellLabelToUuid = {} self._foamFaceLabelToUuid = {} self._foamEdgeLabelToUuid = {} self._foamPointLabelToUuid = {} # generate uuid mapping label = 0 for point in self.mesh.iter(item_type=CUBA.POINT): uid = point.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT) self._foamPointLabelToUuid[label] = uid label += 1 label = 0 for edge in self.mesh.iter(item_type=CUBA.EDGE): uid = edge.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE) self._foamEdgeLabelToUuid[label] = uid label += 1 label = 0 for face in self.mesh.iter(item_type=CUBA.FACE): uid = face.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE) self._foamFaceLabelToUuid[label] = uid label += 1 label = 0 for cell in self.mesh.iter(item_type=CUBA.CELL): uid = cell.uid self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL) self._foamCellLabelToUuid[label] = uid label += 1 # find out boundary patches patchNameFacesMap = OrderedDict() self.facePoints = [] i = 0 for face in self.mesh.iter(item_type=CUBA.FACE): boundary = 'boundary' + str(i) i += 1 if boundary not in patchNameFacesMap: patchNameFacesMap[boundary] = [] patchNameFacesMap[boundary].append( self._uuidToFoamLabelAndType[face.uid][0]) # make compressed list of faces points self.facePoints.append(len(face.points)) for puid in face.points: self.facePoints.append(self._uuidToFoamLabelAndType[puid][0]) # make points coordinate list self.pointCoordinates = [] for point in self.mesh.iter(item_type=CUBA.POINT): for coord in point.coordinates: self.pointCoordinates.append(coord) # make compressed list of cells points self.cellPoints = [] for cell in self.mesh.iter(item_type=CUBA.CELL): self.cellPoints.append(len(cell.points)) for puid in cell.points: self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0]) # make patch information self.patchNames = [] self.patchFaces = [] for patchName in patchNameFacesMap: self.patchNames.append(patchName) self.patchFaces.append(len(patchNameFacesMap[patchName])) for face in patchNameFacesMap[patchName]: self.patchFaces.append(face) if not self.patchNames: error_str = 'Could not initialize with mesh {}. ' error_str += 'Mesh has not boundary face definitions.' raise ValueError(error_str.format(self.mesh.name)) self.patchTypes = [] for i in range(len(self.patchNames)): self.patchTypes.append("patch") # this to have controlDict file for mesh definition mapContent = foam_dicts.dictionaryMaps['pimpleFoam'] controlDict = foam_dicts.parse_map(mapContent['controlDict']) # init objectRegistry and map to mesh name foamface.init(self.name, controlDict) # add mesh to objectRegisty foamface.addMesh(self.name, self.pointCoordinates, self.cellPoints, self.facePoints, self.patchNames, self.patchFaces, self.patchTypes) foamface.createDefaultFields(self.name, 'pimpleFoam', True)
class NumerrinPoolTestCase(unittest.TestCase): """Test case for NumerrinPool class""" def setUp(self): self.mesh = Mesh(name="mesh1") numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode) self.points = [ Point((0.0, 0.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 0.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 1.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 1.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 0.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 0.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 1.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 1.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]], data=DataContainer({CUBA.LABEL: 0})), Face([puids[1], puids[2], puids[6], puids[5]], data=DataContainer({CUBA.LABEL: 1})), Face([puids[0], puids[1], puids[5], puids[4]], data=DataContainer({CUBA.LABEL: 2})), Face([puids[3], puids[2], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 3})), Face([puids[0], puids[1], puids[2], puids[3]], data=DataContainer({CUBA.LABEL: 4})), Face([puids[4], puids[5], puids[6], puids[7]], data=DataContainer({CUBA.LABEL: 5})) ] self.edge = Edge([puids[0], puids[3]]) self.mesh.add(self.faces) self.cells = [Cell(puids)] self.puids = puids self.mesh.add(self.cells) self.variablename = self.mesh.name + "Velocity" self.variable = tuple([(0.0, 0.0, 0.0) for _ in self.points]) self.boundaries = {} for i in range(6): self.boundaries['boundary' + str(i)] = [self.faces[i].uid] def test_import_mesh(self): """Test import_mesh method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) self.assertEqual( numerrin.meshsize(pool.ph, self.mesh.name)[0], len(self.points)) self.assertEqual( numerrin.meshsize(pool.ph, self.mesh.name)[2], len(self.faces)) self.assertEqual( numerrin.meshsize(pool.ph, self.mesh.name)[3], len(self.cells)) def test_clear(self): """Test clear method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) pool.clear() with self.assertRaises(RuntimeError): numerrin.meshsize(pool.ph, self.mesh.name) def test_variable_type(self): """Test variable_type method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) self.assertEqual(pool.variable_type(self.mesh.name), "Mesh") def test_variable_rank(self): """Test variable_rank method """ pool = NumerrinPool() pool.put_variable(self.variablename, self.variable) self.assertEqual(pool.variable_rank(self.variablename), 2) def test_get_variable(self): """Test get_variable method """ pool = NumerrinPool() pool.put_variable(self.variablename, self.variable) self.assertEqual(pool.get_variable(self.variablename), self.variable) def test_put_variable(self): """Test put_variable method """ pool = NumerrinPool() pool.put_variable(self.variablename, self.variable) self.assertEqual(pool.get_variable(self.variablename), self.variable) def test_modify_variable(self): """Test modify_variable method """ pool = NumerrinPool() pool.put_variable(self.variablename, self.variable) oldvar = pool.get_variable(self.variablename) modvar = tuple([(10.0, 10.0, 10.0) for _ in oldvar]) pool.modify_variable(self.variablename, modvar) newvar = pool.get_variable(self.variablename) self.assertNotEqual(oldvar, newvar) def test_delete_mesh_and_variables(self): """Test delete_mesh_and_variables method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) pool.put_variable(self.variablename, self.variable) pool.delete_mesh_and_variables(self.mesh.name) with self.assertRaises(RuntimeError): pool.get_variable(self.variablename) with self.assertRaises(RuntimeError): numerrin.meshsize(pool.ph, self.mesh.name) def test_export_mesh(self): """Test export_mesh method """ pool = NumerrinPool() pool.import_mesh(self.mesh.name, self.mesh, self.boundaries) boundary_names = self.boundaries.keys() (smesh, mmap, boundaries) = pool.export_mesh(self.mesh.name, self.mesh.name, boundary_names) self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.POINT)), sum(1 for _ in self.mesh.iter(item_type=CUBA.POINT))) self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.FACE)), sum(1 for _ in self.mesh.iter(item_type=CUBA.FACE))) self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.CELL)), sum(1 for _ in self.mesh.iter(item_type=CUBA.CELL))) self.assertEqual( set([p.coordinates for p in smesh.iter(item_type=CUBA.POINT)]), set([p.coordinates for p in self.mesh.iter(item_type=CUBA.POINT)])) self.assertEqual(boundaries.keys(), boundary_names)
add_velocity(body_centered) points = array([ [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [2, 0, 0], [3, 0, 0], [3, 1, 0], [2, 1, 0], [2, 0, 1], [3, 0, 1], [3, 1, 1], [2, 1, 1]], 'f') cells = [ [0, 1, 2, 3], # tetra [4, 5, 6, 7, 8, 9, 10, 11]] # hex faces = [[2, 7, 11]] edges = [[1, 4], [3, 8]] mesh = Mesh('mesh_example') # add points uids = mesh.add((Point(coordinates=point, data=DataContainer(TEMPERATURE=index)) for index, point in enumerate(points))) # add edges edge_iter = (Edge(points=[uids[index] for index in element], data=DataContainer(TEMPERATURE=index + 20)) for index, element in enumerate(edges)) edge_uids = mesh.add(edge_iter) # add faces face_uids = mesh.add((Face(points=[uids[index] for index in element], data=DataContainer(TEMPERATURE=index + 30))
def test_compare_mesh_datasets_equal(self): # given mesh = Mesh(name="test") reference = Mesh(name="test") point_list = create_points_with_id() edge_list = create_edges() face_list = create_faces() cell_list = create_cells() data = DataContainer() mesh.add(point_list) mesh.add(edge_list) mesh.add(face_list) mesh.add(cell_list) reference.add(point_list) reference.add(edge_list) reference.add(face_list) reference.add(cell_list) mesh.data = data reference.data = data # this should pass without problems compare_mesh_datasets(mesh, reference, testcase=self)
def read_modelpart(self, filename): """ Reads a Kratos formated modelpart for KratosCFD wrapper This functions translates each of the modelpart meshes to one simphony mesh. Properties in the modelpart related to boundary conditions are stored in simphony conditions and referenced in CUBA.CONDITION inside the mesh. Properties in the modelpart not relared to boundary conditions are stored in simphony as materials and referenced in CUBA.MATERIAL inside the mesh. """ model_part = KRTS.ModelPart("FluidPart") self.addNodalVariablesToModelpart(model_part) model_part_io_fluid = KRTS.ModelPartIO(filename) model_part_io_fluid.ReadModelPart(model_part) smp_meshes = [] smp_conditions = [] smp_materials = [] cfd_pe = api.Cfd() cfd_pe.data[CUBA.DATA_SET] = [] for i in xrange(1, model_part.NumberOfMeshes()): mesh_name = 'fluid_' + str(i) mesh = SMesh(name=mesh_name) # Export mesh data to Simphony self.exportKratosNodes(model_part, mesh, i) self.exportKratosElements(model_part, mesh, i) self.exportKratosConditions(model_part, mesh, i) properties = model_part.GetProperties(0)[i] # Fill the boundary condition for the mesh condition = self._convertBc(properties, mesh_name) # Fill the material for the mesh material = self._convertMaterial(properties, mesh_name) # Save the relations meshData = mesh.data meshData[CUBA.CONDITION] = condition.name meshData[CUBA.MATERIAL] = material.name mesh.data = meshData # Pack the return objects smp_meshes.append(mesh) smp_conditions.append(condition) smp_materials.append(material) # Add to the pe? cfd_pe.data[CUBA.DATA_SET].append(mesh.name) return { 'datasets': smp_meshes, 'conditions': smp_conditions, 'materials': smp_materials, 'pe': cfd_pe, }
class NumerrinMeshTestCase(unittest.TestCase): """Test case for NumerrinMesh class""" def setUp(self): self.mesh = Mesh(name="mesh1") numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode) self.pool = NumerrinPool() self.points = [ Point((0.0, 0.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 0.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 1.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 1.0, 0.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 0.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 0.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((1.0, 1.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })), Point((0.0, 1.0, 1.0), data=DataContainer({ CUBA.VELOCITY: (1, 0, 0), CUBA.PRESSURE: 4.0 })) ] puids = self.mesh.add_points(self.points) self.puids = puids self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add_faces(self.faces) self.cells = [Cell(puids)] self.puids = puids self.mesh.add_cells(self.cells) def test_get_point(self): """Test get_point method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) point = self.points[4] point_f = num_mesh.get(point.uid) self.assertEqual(point.coordinates, point_f.coordinates) self.assertEqual(point.data[CUBA.PRESSURE], point_f.data[CUBA.PRESSURE]) self.assertEqual(point.data[CUBA.VELOCITY], point_f.data[CUBA.VELOCITY]) def test_get_edge(self): """Test get_edge method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) uid = num_mesh._numEdgeLabelToUuid[0] edge = num_mesh.get(uid) self.assertEqual(edge.uid, uid) def test_get_face(self): """Test get_face method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) face = self.faces[4] face_f = num_mesh.get(face.uid) self.assertEqual(face.points, face_f.points) def test_get_cell(self): """Test get_cell method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) cell = self.cells[0] cell_f = num_mesh.get(cell.uid) self.assertEqual(set(cell.points), set(cell_f.points)) def test_add_points(self): """Test add_points method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.add(self.points) def test_add_edges(self): """Test add_edges method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.add([Edge([self.puids[0], self.puids[3]])]) def test_add_faces(self): """Test add_faces method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.add(self.faces) def test_add_cells(self): """Test add_cells method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.add(self.cells) def test_update_points(self): """Test update_points method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) points = self.points points[0].data[CUBA.VELOCITY] = (2, 1, 3) num_mesh.update(points) point_f = num_mesh.get(points[0].uid) self.assertIsInstance(point_f.data, DataContainer) self.assertEqual(points[0].data, point_f.data) def test_update_edges(self): """Test update_edges method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.update([Edge([self.puids, self.puids[3]])]) def test_update_faces(self): """Test update_faces method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) with self.assertRaises(NotImplementedError): num_mesh.update(self.faces) def test_iter_edges(self): """Test iter_edges method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) self.assertEqual(sum(1 for _ in num_mesh.iter(item_type=CUBA.EDGE)), num_mesh.count_of(CUBA.EDGE)) def test_iter_faces(self): """Test iter_faces method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) for face_f in num_mesh.iter(item_type=CUBA.FACE): face = self.mesh.get(face_f.uid) self.assertEqual(face.points, face_f.points) def test_iter_points(self): """Test iter_points method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) for point_f in num_mesh.iter(item_type=CUBA.POINT): point = self.mesh.get(point_f.uid) self.assertEqual(point.data[CUBA.VELOCITY], point_f.data[CUBA.VELOCITY]) self.assertEqual(point.data[CUBA.PRESSURE], point_f.data[CUBA.PRESSURE]) def test_has_faces(self): """Test has_faces method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) self.assertTrue(num_mesh.has_type(CUBA.FACE)) def test_has_cells(self): """Test has_cells method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) self.assertTrue(num_mesh.has_type(CUBA.CELL)) def test_count_of(self): """Test count_of method """ num_mesh = NumerrinMesh('test_mesh', self.mesh, self.pool) item_type = CUBA.POINT self.assertEqual(num_mesh.count_of(item_type), self.mesh.count_of(item_type)) item_type = CUBA.EDGE self.assertEqual(num_mesh.count_of(item_type), 12) item_type = CUBA.FACE self.assertEqual(num_mesh.count_of(item_type), self.mesh.count_of(item_type)) item_type = CUBA.CELL self.assertEqual(num_mesh.count_of(item_type), self.mesh.count_of(item_type))
def test_compare_mesh_datasets_not_equal(self): # given mesh = Mesh(name="test") reference = Mesh(name="test_ref") point_list = create_particles_with_id() edge_list = create_edges() face_list = create_faces() cell_list = create_cells() data = create_data_container() mesh.add_points(point_list) mesh.add_edges(edge_list) mesh.add_faces(face_list) mesh.add_cells(cell_list) reference.add_points(point_list) reference.add_edges(edge_list) reference.add_faces(face_list) reference.add_cells(cell_list) mesh.data = data reference.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_points = create_points_with_id() mesh = Mesh(name=reference.name) mesh.add_points(test_points) mesh.add_edges(edge_list) mesh.add_faces(face_list) mesh.add_cells(cell_list) mesh.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_edges = create_edges() mesh = Mesh(name=reference.name) mesh.add_points(point_list) mesh.add_edges(test_edges) mesh.add_faces(face_list) mesh.add_cells(cell_list) mesh.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_faces = create_faces() mesh = Mesh(name=reference.name) mesh.add_points(point_list) mesh.add_edges(edge_list) mesh.add_faces(test_faces) mesh.add_cells(cell_list) mesh.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_cells = create_cells() mesh = Mesh(name=reference.name) mesh.add_points(point_list) mesh.add_edges(edge_list) mesh.add_faces(face_list) mesh.add_cells(test_cells) mesh.data = data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self) # given test_data = DataContainer() mesh = Mesh(name=reference.name) mesh.add_points(point_list) mesh.add_edges(edge_list) mesh.add_faces(face_list) mesh.add_cells(cell_list) mesh.data = test_data # when/then with self.assertRaises(AssertionError): compare_mesh_datasets(mesh, reference, testcase=self)
class WrapperTestCase(unittest.TestCase): """Test case for Wrapper class""" def setUp(self): self.mesh = Mesh(name="mesh1") self.points = [ Point((0.0, 0.0, 0.0)), Point((1.0, 0.0, 0.0)), Point((1.0, 1.0, 0.0)), Point((0.0, 1.0, 0.0)), Point((0.0, 0.0, 1.0)), Point((1.0, 0.0, 1.0)), Point((1.0, 1.0, 1.0)), Point((0.0, 1.0, 1.0)) ] puids = self.mesh.add(self.points) self.faces = [ Face([puids[0], puids[3], puids[7], puids[4]]), Face([puids[1], puids[2], puids[6], puids[5]]), Face([puids[0], puids[1], puids[5], puids[4]]), Face([puids[3], puids[2], puids[6], puids[7]]), Face([puids[0], puids[1], puids[2], puids[3]]), Face([puids[4], puids[5], puids[6], puids[7]]) ] self.mesh.add(self.faces) self.cells = [Cell(puids)] self.puids = puids self.mesh.add(self.cells) def test_add_dataset(self): """Test add_dataset method """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 1) def test_remove_dataset(self): """Test remove_dataset method """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) wrapper.remove_dataset(self.mesh.name) with self.assertRaises(KeyError): wrapper.get_dataset(self.mesh.name) def test_get_dataset(self): """Test get_dataset method """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) mesh_inside_wrapper = wrapper.get_dataset(self.mesh.name) self.assertEqual(self.mesh.name, mesh_inside_wrapper.name) for point in self.mesh.iter(item_type=CUBA.POINT): point_w = mesh_inside_wrapper._get_point(point.uid) self.assertEqual(point.coordinates, point_w.coordinates) for face in self.mesh.iter(item_type=CUBA.FACE): face_w = mesh_inside_wrapper._get_face(face.uid) self.assertEqual(face.points, face_w.points) for cell in self.mesh.iter(item_type=CUBA.CELL): cell_w = mesh_inside_wrapper._get_cell(cell.uid) self.assertEqual(set(cell.points), set(cell_w.points)) def test_iter_datasets(self): """Test iter_datsets method """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) mesh2 = self.mesh mesh2.name = "mesh2" wrapper.add_dataset(mesh2) self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 2) def test_multiple_meshes(self): """Test multiple meshes inside wrapper """ wrapper = Wrapper() wrapper.add_dataset(self.mesh) mesh2 = self.mesh mesh2.name = "mesh2" wrapper.add_dataset(mesh2) mesh_inside_wrapper1 = wrapper.get_dataset(self.mesh.name) mesh_inside_wrapper2 = wrapper.get_dataset(mesh2.name) self.assertEqual( sum(1 for _ in mesh_inside_wrapper1.iter(item_type=CUBA.POINT)), sum(1 for _ in mesh_inside_wrapper2.iter(item_type=CUBA.POINT))) def test_run_time(self): """Test that field variable value is changed after consecutive calls of run method """ wrapper = Wrapper() name = 'simplemesh' corner_points = ((0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)) extrude_length = 1 nex = 3 ney = 3 nez = 1 create_quad_mesh(name, wrapper, corner_points, extrude_length, nex, ney, nez) wrapper.CM[CUBA.NAME] = name wrapper.CM_extensions[CUBAExt.GE] = (CUBAExt.INCOMPRESSIBLE, CUBAExt.LAMINAR_MODEL) wrapper.SP[CUBA.TIME_STEP] = 1 wrapper.SP[CUBA.NUMBER_OF_TIME_STEPS] = 1 wrapper.SP[CUBA.DENSITY] = 1.0 wrapper.SP[CUBA.DYNAMIC_VISCOSITY] = 1.0 wrapper.BC[CUBA.VELOCITY] = { 'inflow': ('fixedValue', (0.1, 0, 0)), 'outflow': 'zeroGradient', 'walls': ('fixedValue', (0, 0, 0)), 'frontAndBack': 'empty' } wrapper.BC[CUBA.PRESSURE] = { 'inflow': 'zeroGradient', 'outflow': ('fixedValue', 0), 'walls': 'zeroGradient', 'frontAndBack': 'empty' } mesh_inside_wrapper = wrapper.get_dataset(name) wrapper.run() # sum data pointwise old_vel = 0.0 old_pres = 0.0 for point in mesh_inside_wrapper.iter(item_type=CUBA.POINT): velo = point.data[CUBA.VELOCITY] old_vel += math.sqrt(velo[0] * velo[0] + velo[1] * velo[1] + velo[2] * velo[2]) old_pres += point.data[CUBA.PRESSURE] wrapper.SP[CUBA.DENSITY] = 5.0 wrapper.run() # sum data pointwise new_vel = 0.0 new_pres = 0.0 for point in mesh_inside_wrapper.iter(item_type=CUBA.POINT): velo = point.data[CUBA.VELOCITY] new_vel += math.sqrt(velo[0] * velo[0] + velo[1] * velo[1] + velo[2] * velo[2]) new_pres += point.data[CUBA.PRESSURE] self.assertNotAlmostEqual(old_vel, new_vel, 5) self.assertNotAlmostEqual(old_pres, new_pres, 5)