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)
Exemplo n.º 2
0
    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,
        }
Exemplo n.º 3
0
    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)
Exemplo n.º 5
0
    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)
Exemplo n.º 6
0
    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 = {}
Exemplo n.º 9
0
 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))
Exemplo n.º 13
0
    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)
Exemplo n.º 14
0

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)
Exemplo n.º 18
0
    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))
Exemplo n.º 22
0
    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)
Exemplo n.º 24
0
    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)
Exemplo n.º 28
0
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))
Exemplo n.º 29
0
    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)
Exemplo n.º 30
0
    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,
        }
Exemplo n.º 31
0
 def __init__(self, name):
     Mesh.__init__(self, name)
     self._boundaries = {}
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))
Exemplo n.º 33
0
    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)