Exemplo n.º 1
0
    def __init__(self, nodes, elements, edges, mesh_files):
        """
        Test case for a Lagrange mesh. Tries to test an Argyris mesh.
        """
        for mesh_file in mesh_files:
            self.nodes = nodes
            # The mesh classes try to flatten nodes if possible. Do it here too.
            if np.all(self.nodes[:, -1] == self.nodes[0, -1]):
                self.nodes = self.nodes[:, 0:-1]
            self.elements = elements
            self.edges = edges
            mesh = meshes.mesh_factory(*mesh_file)
            parsed_mesh = parsers.parser_factory(*mesh_file)

            npt.assert_equal(self.nodes, mesh.nodes)
            npt.assert_equal(self.elements, mesh.elements)
            if parsed_mesh.edges:
                assert set(self.edges) == reduce(
                    lambda a, b: a + b, mesh.edge_collections.values())

            npt.assert_almost_equal(meshtools.project_nodes(
                lambda x: x[0:2], self.elements, self.nodes),
                                    self.nodes[:, 0:2],
                                    decimal=10)

            if parsed_mesh.edges:
                assert set(map(lambda x : x[0:-1], self.edges)) == \
                       set(map(lambda x : x[0:-1],
                           meshtools.extract_boundary_edges(self.elements)))

            # Test Argyris stuff.
            if self.elements.shape[1] == 6:
                TestArgyrisCase(mesh_file, parsed_mesh)
Exemplo n.º 2
0
    def __init__(self, nodes, elements, edges, mesh_files):
        """
        Test case for a Lagrange mesh. Tries to test an Argyris mesh.
        """
        for mesh_file in mesh_files:
            self.nodes = nodes
            # The mesh classes try to flatten nodes if possible. Do it here too.
            if np.all(self.nodes[:, -1] == self.nodes[0, -1]):
                self.nodes = self.nodes[:,0:-1]
            self.elements = elements
            self.edges = edges
            mesh = meshes.mesh_factory(*mesh_file)
            parsed_mesh = parsers.parser_factory(*mesh_file)

            npt.assert_equal(self.nodes, mesh.nodes)
            npt.assert_equal(self.elements, mesh.elements)
            if parsed_mesh.edges:
                assert set(self.edges) == reduce(lambda a, b : a + b,
                                                 mesh.edge_collections.values())

            npt.assert_almost_equal(meshtools.project_nodes(lambda x : x[0:2],
                                                     self.elements, self.nodes),
                             self.nodes[:,0:2], decimal=10)

            if parsed_mesh.edges:
                assert set(map(lambda x : x[0:-1], self.edges)) == \
                       set(map(lambda x : x[0:-1],
                           meshtools.extract_boundary_edges(self.elements)))

            # Test Argyris stuff.
            if self.elements.shape[1] == 6:
                TestArgyrisCase(mesh_file, parsed_mesh)
Exemplo n.º 3
0
    def __init__(self, mesh_file, parsed_mesh):
        argyris_mesh = meshes.mesh_factory(*mesh_file, argyris=True)
        lagrange_mesh = meshes.mesh_factory(*mesh_file)
        assert argyris_mesh.elements.shape == (parsed_mesh.elements.shape[0],
                                               21)

        stacked_nodes = dict()
        edges_by_midpoint = dict()
        for element in argyris_mesh.elements:
            for local_number, global_number in enumerate(element[0:3]):
                corner_nodes = (element[3 + 2 * local_number],
                                element[3 + 2 * local_number + 1],
                                element[9 + 3 * local_number],
                                element[9 + 3 * local_number + 1],
                                element[9 + 3 * local_number + 2])
                if stacked_nodes.has_key(global_number):
                    assert corner_nodes == stacked_nodes[global_number]
                else:
                    stacked_nodes[global_number] = corner_nodes
                for node in corner_nodes:
                    npt.assert_almost_equal(
                        argyris_mesh.nodes[global_number - 1, :],
                        argyris_mesh.nodes[node - 1, :])

            for midpoint_number, local_edge in enumerate([[0, 1], [0, 2],
                                                          [1, 2]]):
                midpoint = element[18 + midpoint_number]
                if edges_by_midpoint.has_key(midpoint):
                    npt.assert_equal(edges_by_midpoint[midpoint],
                                     element[local_edge])
                else:
                    edges_by_midpoint[midpoint] = element[local_edge]

        # Ensure that the Argyris mesh and the Lagrange mesh come up with the
        # same edges.
        for name, collection in lagrange_mesh.edge_collections.items():
            argyris_collection = \
                map(lambda x : x.edge,
                    filter(lambda x : x.name == name,
                           argyris_mesh.node_collections)[0].edges)
            for edge in collection:
                argyris_edge = (min(edge[0:2]), max(edge[0:2]), edge[2])
                assert argyris_edge in argyris_collection
Exemplo n.º 4
0
    def __init__(self, mesh_file, parsed_mesh):
        argyris_mesh = meshes.mesh_factory(*mesh_file, argyris=True)
        lagrange_mesh = meshes.mesh_factory(*mesh_file)
        assert argyris_mesh.elements.shape == (parsed_mesh.elements.shape[0],21)

        stacked_nodes = dict()
        edges_by_midpoint = dict()
        for element in argyris_mesh.elements:
            for local_number, global_number in enumerate(element[0:3]):
                corner_nodes = (element[3 + 2*local_number],
                                element[3 + 2*local_number + 1],
                                element[9 + 3*local_number],
                                element[9 + 3*local_number + 1],
                                element[9 + 3*local_number + 2])
                if stacked_nodes.has_key(global_number):
                    assert corner_nodes == stacked_nodes[global_number]
                else:
                    stacked_nodes[global_number] = corner_nodes
                for node in corner_nodes:
                    npt.assert_almost_equal(
                            argyris_mesh.nodes[global_number - 1, :],
                            argyris_mesh.nodes[node - 1, :])

            for midpoint_number, local_edge in enumerate([[0,1], [0,2], [1,2]]):
                midpoint = element[18 + midpoint_number]
                if edges_by_midpoint.has_key(midpoint):
                    npt.assert_equal(edges_by_midpoint[midpoint],
                                     element[local_edge])
                else:
                    edges_by_midpoint[midpoint] = element[local_edge]

        # Ensure that the Argyris mesh and the Lagrange mesh come up with the
        # same edges.
        for name, collection in lagrange_mesh.edge_collections.items():
            argyris_collection = \
                map(lambda x : x.edge,
                    filter(lambda x : x.name == name,
                           argyris_mesh.node_collections)[0].edges)
            for edge in collection:
                argyris_edge = (min(edge[0:2]), max(edge[0:2]), edge[2])
                assert argyris_edge in argyris_collection
Exemplo n.º 5
0
    x2, y2 = coordinates[1]
    x3, y3 = coordinates[2]

    return np.linalg.inv(np.array([[x1 - x3, x2 - x3],
                                   [y1 - y3, y2 - y3]]))


if __name__ == '__main__':
    eps = sys.float_info.epsilon
    # USER SET PARAMETERS
    reynolds = 1
    eps = 0.01
    mesh_file = './files/box.mesh'

    print "Loading and parsing the mesh..."
    domain = msh.mesh_factory(mesh_file)
    elements = domain.elements
    nodes = np.unique(elements)
    pnodes = np.unique(elements.T[:3])
    interior_nodes = domain.interior_nodes
    coordinates = domain.nodes
    n, m = len(nodes), len(pnodes)
    k = len(interior_nodes)

    weight = 1 / 6.0
    gauss_pts = np.array([[0.5, 0.0],
                          [0.0, 0.5],
                          [0.5, 0.5]])

    A = sp.lil_matrix((n, n))
    Bup = sp.lil_matrix((n, m))
Exemplo n.º 6
0
from cfem import *
sys.path.append(os.path.expanduser("~/Documents/Code/ArgyrisPack"))
sys.path.append(os.path.expanduser("~/Documents/Code/PODSUPG"))

import ap.mesh.meshes as m
import supg.core.gmsh as gmsh
import supg.core.supg as spg
import supg.cdr.Operators2DCDR as operators

# Create example data.
mesh_file = util.unique_file(suffix=".msh")
geo_file = util.unique_file(suffix=".geo")
gmsh.write_geo_file(gmsh.unit_square(0.05), geo_file=geo_file)
gmsh.call_gmsh(geo_file=geo_file, mesh_file=mesh_file)
mesh = m.mesh_factory(mesh_file)

# compute the PODSUPG operators too.
fe_facade = spg.SUPGFacade(order=2)
ops = operators.Operators2DCDR(mesh, fe_facade, stabilization_coeff=3.0)

if mesh.interior_nodes.min() == 0:
    last_boundary_node = max(mesh.boundary_nodes['land'])
else:
    last_boundary_node = max(mesh.boundary_nodes['land']) - 1
first_interior_node = last_boundary_node + 1

mass = get_matrix('mass', mesh, stabilization_coeff=3.0).todense()
convection = get_matrix('convection', mesh, stabilization_coeff=3.0).todense()
stiffness = get_matrix('stiffness', mesh, stabilization_coeff=3.0).todense()
hessian = get_matrix('hessian', mesh, stabilization_coeff=3.0).todense()
Exemplo n.º 7
0
from cfem import *

sys.path.append(os.path.expanduser("~/Documents/Code/ArgyrisPack"))
sys.path.append(os.path.expanduser("~/Documents/Code/PODSUPG"))

import ap.mesh.meshes as m
import supg.core.gmsh as gmsh
import supg.core.supg as spg
import supg.cdr.Operators2DCDR as operators

# Create example data.
mesh_file = util.unique_file(suffix=".msh")
geo_file = util.unique_file(suffix=".geo")
gmsh.write_geo_file(gmsh.unit_square(0.05), geo_file=geo_file)
gmsh.call_gmsh(geo_file=geo_file, mesh_file=mesh_file)
mesh = m.mesh_factory(mesh_file)

# compute the PODSUPG operators too.
fe_facade = spg.SUPGFacade(order=2)
ops = operators.Operators2DCDR(mesh, fe_facade, stabilization_coeff=3.0)

if mesh.interior_nodes.min() == 0:
    last_boundary_node = max(mesh.boundary_nodes["land"])
else:
    last_boundary_node = max(mesh.boundary_nodes["land"]) - 1
first_interior_node = last_boundary_node + 1

mass = get_matrix("mass", mesh, stabilization_coeff=3.0).todense()
convection = get_matrix("convection", mesh, stabilization_coeff=3.0).todense()
stiffness = get_matrix("stiffness", mesh, stabilization_coeff=3.0).todense()
hessian = get_matrix("hessian", mesh, stabilization_coeff=3.0).todense()
Exemplo n.º 8
0
def stokes():
    eps = sys.float_info.epsilon
    # USER SET PARAMETERS
    reynolds = 1e0
    eps = 1e-4 / reynolds
    mesh_file = 'convergence/01.mesh'

    root_dir = './files/'
    print "Loading and parsing the mesh..."
    domain = m.mesh_factory(root_dir + mesh_file)
    elements = domain.elements
    nodes = np.unique(elements)
    pnodes = np.unique(elements.T[:3])
    interior_nodes = domain.interior_nodes
    coordinates = domain.nodes
    n, m = len(nodes), len(pnodes)

    weight = 1 / 6.0
    gauss_pts = np.array([[0.5, 0.0],
                          [0.0, 0.5],
                          [0.5, 0.5]])

    A = sp.lil_matrix((n, n))
    B_up = sp.lil_matrix((n, m))
    B_vp = sp.lil_matrix((n, m))
    F_x = np.zeros(n)
    F_y = F_x.copy()

    quad_basis = fn.Quadratic_Basis_Function()
    lin_basis = fn.Linear_Basis_Function()

    counter = 1
    total = len(elements)
    print "Constructing system..."
    for element in elements:
        #if np.mod(counter, 100) == 1:
            #print "Element %d of %d..." % (counter, total)
        # Precalculate some stuff
        element_coords = get_coordinates(element, domain.nodes)
        B = calculate_B(element_coords[:3])
        detJ = 1 / np.abs(np.linalg.det(B))
        weight_scaled = weight * detJ

        # Allocate local matrices
        local_A = sp.lil_matrix((6, 6))
        #local_T = sp.lil_matrix((3, 3))
        local_B_up = sp.lil_matrix((6, 3))
        local_B_vp = sp.lil_matrix((6, 3))
        local_F_x = np.zeros(n)
        local_F_y = np.zeros(n)

        for i in xrange(6):
            # Assemble load vectors
            for point in gauss_pts:
                x_g, y_g = point
                local_F_x[i] += weight_scaled * f1(x_g, y_g)
                local_F_y[i] += weight_scaled * f2(x_g, y_g)

            F_x[element[i] - 1] += local_F_x[i]
            F_y[element[i] - 1] += local_F_y[i]

            for j in xrange(6):
                # Assemble S
                for point in gauss_pts:
                    x_g, y_g = point
                    local_A[i, j] += (weight_scaled / reynolds) * np.dot(
                        np.dot(quad_basis.grad(j, x_g, y_g), B),
                        np.dot(B.T, quad_basis.grad(i, x_g, y_g)))

                A[element[i] - 1, element[j] - 1] += local_A[i, j]

                if j < 3:
                    # Assemble Gx and Gy
                    for point in gauss_pts:
                        x_g, y_g = point
                        local_B_up[i, j] += weight_scaled * (
                            lin_basis(j, x_g, y_g) *
                            np.dot(quad_basis.grad(i, x_g, y_g), B[0]))
                        local_B_vp[i, j] += weight_scaled * (
                            lin_basis(j, x_g, y_g) *
                            np.dot(quad_basis.grad(i, x_g, y_g), B[1]))

                    pnode_j = np.where(pnodes == element[j])[0][0]
                    B_up[element[i] - 1, pnode_j] += local_B_up[i, j]
                    B_vp[element[i] - 1, pnode_j] += local_B_vp[i, j]

        counter += 1

    A = A.tocsr()
    A = A[interior_nodes - 1, :]
    A = A.tocsc()
    A = A[:, interior_nodes - 1]

    B_up = B_up.tocsr()
    B_up = B_up[interior_nodes - 1, :]

    B_vp = B_vp.tocsr()
    B_vp = B_vp[interior_nodes - 1, :]

    F_x = F_x[interior_nodes - 1, :]
    F_y = F_y[interior_nodes - 1, :]

    # Update dimensions since we nuked the Dirchlet BCs, all = 0
    k = len(interior_nodes)

    M = sp.bmat([[A, sp.csc_matrix((k, k))],
                 [sp.csc_matrix((k, k)), A]]) + \
        sp.bmat([[B_up.dot(B_up.T), B_up.dot(B_vp.T)],
                 [B_vp.dot(B_up.T), B_vp.dot(B_vp.T)]]) / eps
    M = M.tocsc()

    print "Solving the linear systems..."
    UV = np.zeros(2 * k)
    UV = spl.gmres(M, np.append(F_x, F_y))[0]

    P = np.zeros(m)
    P = -sp.bmat([[B_up.T, B_vp.T]]).dot(UV) / eps

    U = np.zeros(n)
    V = np.zeros(n)
    U[interior_nodes - 1] += UV[:k]
    V[interior_nodes - 1] += UV[k:2 * k]

    UVP = np.zeros(2 * n + m)
    UVP[:n] = U[:]
    UVP[n:2 * n] = V[:]
    UVP[2 * n:] = P[:]

    # POST PROCESSING for system one
    x, y = coordinates[pnodes - 1].T
    tri = np.zeros(np.shape(elements[:, :3]))
    for i, element in enumerate(elements[:, :3]):
        for j, vert in enumerate(element):
            tri[i, j] = np.where(pnodes == vert)[0][0]

    print "Saving some data..."
    p = UVP[2 * n:]
    u = UVP[n:2 * n]
    v = UVP[:n]
    np.savetxt('./files/UVP.txt', UVP)
    np.savetxt('./files/tri.txt', tri)
    np.savetxt('./files/x.txt', x)
    np.savetxt('./files/y.txt', y)
    np.savetxt('./files/p.txt', p)
    np.savetxt('./files/u.txt', u[pnodes - 1])
    np.savetxt('./files/v.txt', v[pnodes - 1])
    print "All done! Thank you, come again!\n\n"