コード例 #1
0
    def markBoundaries(self, mesh):
        self.boundaries = dolfin.MeshFunction("size_t", mesh,
                                              mesh.topology().dim() - 1)
        self.boundaries.set_all(0)
        self.subdomains['left'].mark(self.boundaries, 1)
        self.subdomains['top'].mark(self.boundaries, 2)
        self.subdomains['right'].mark(self.boundaries, 3)
        self.subdomains['bottom'].mark(self.boundaries, 4)
        self.subdomains['front'].mark(self.boundaries, 5)
        self.subdomains['back'].mark(self.boundaries, 6)

        #mark each electrode by its position in the list, plus an offset
        for electrode in self.electrodes:
            electrode.mark(self.boundaries,
                           7 + self.electrodes.index(electrode))
コード例 #2
0
    def integration_measure_over_expression(mesh, expr, threshold):

        mf = dolfin.MeshFunction('size_t', mesh, mesh.geometric_dimension())
        dx_subdomains = dolfin.dx(subdomain_data=mf, domain=mesh)

        V_DG = dolfin.FunctionSpace(mesh, 'DG', 0)

        mf.array()[:] = np.array(
            dolfin.project(expr, V_DG).vector().get_local() > threshold,
            np.uint)

        dx_interior = dx_subdomains(1)
        dx_exterior = dx_subdomains(0)

        return dx_interior, dx_exterior
コード例 #3
0
    def generate_mesh(self):
        mesh = self.user_just_generate_mesh()

        cf = dolfin.MeshFunction('size_t', mesh, mesh.topology().dim(), 0)

        self.mesh = mesh
        self.cf = cf

        # initialize facets-cells mapping
        D = self.dim
        mesh.init(D - 1, D)

        d = self.user_tag_cells(cf)

        self.cell_regions = d['tag_to_cell_values']
コード例 #4
0
	def init_submeshes(self):
		self.oversampled_submeshes = []
		self.patch_submeshes = []
		self.patch_vertex_parent_maps = []
		self.patch_cell_parent_maps = []
		for marker in self.markers:
			patch_submesh = dolfin.SubMesh(self.mesh, marker, 2)
			self.patch_submeshes.append(patch_submesh)
			patch_vertex_parent_map = patch_submesh.data().array("parent_vertex_indices", 0)
			self.patch_vertex_parent_maps.append(patch_vertex_parent_map)
			patch_cell_parent_map = patch_submesh.data().array("parent_cell_indices", self.basedim)
			self.patch_cell_parent_maps.append(patch_cell_parent_map)
			oversampled_marker = dolfin.MeshFunction('size_t', self.mesh, self.basedim, 0)
			oversampled_marker.array()[numpy.where(marker.array() > 0)] = 1
			self.oversampled_submeshes.append(dolfin.SubMesh(self.mesh, oversampled_marker, 1))
コード例 #5
0
def test_two_line():
    mesh = df.UnitCubeMesh(8, 8, 8)
    f = df.MeshFunction('size_t', mesh, 1, 0)
    df.CompiledSubDomain('near(x[0], x[1]) && near(x[1], x[2])').mark(f, 1)

    # One more line
    df.CompiledSubDomain('near(x[0], x[1]) && near(1., x[2])').mark(f, 1)

    d = curve_distance(f, nlayers=10, outside_val=-1)
    # See if we got the distance right
    A, B, C = np.array([0., 0, 0]), np.array([1, 1., 1]), np.array([0., 0, 1.])

    dofs_x = d.function_space().tabulate_dof_coordinates().reshape((-1, 3))
    for xi in dofs_x:
        assert abs(d(xi) -
                   min((distance(A, B, xi), distance(C, B, xi)))) < 1E-13
コード例 #6
0
ファイル: test_boundary.py プロジェクト: C6xf/fish2eod
def simple_domain(size=15):
    """Construct a simple meshfunction representing domains.

    Simple is defined as 0 defined on the left half (x < 0.5) and 1 on the right side (x > 0.5)

    :param size: Resolution of the mesh
    :return: Domain function
    """
    mesh = df.UnitSquareMesh(size, size)
    domain = df.MeshFunction("size_t", mesh, 2)

    # make MeshFunction with right = 1 and left = 0
    for c in df.cells(mesh):
        if c.midpoint()[0] > 0.5:
            domain[c] = 1
    return domain
コード例 #7
0
def test_plot_facetfunction(dim, wireframe):
    mesh = get_mesh(3)
    ffun = df.MeshFunction("size_t", mesh, 2)
    ffun.set_all(0)

    fixed = df.CompiledSubDomain("near(x[0], 0) && on_boundary")
    free = df.CompiledSubDomain("near(x[0], 1) && on_boundary")

    fixed_marker = 1
    fixed.mark(ffun, fixed_marker)

    # Mark the second subdomain with value 2

    free_marker = 2
    free.mark(ffun, free_marker)
    plot(ffun, show=False)
コード例 #8
0
def boring(mesh_2d, inner_size):
    '''
    A mesh2d is assumed to be be a cube [-inner_size, inner_size]^2.
    The curve is mostly a collection of boundary edges.
    '''
    facet_f = df.MeshFunction('size_t', mesh_2d, 1, 0)
    mesh_2d.init(2, 1)

    # Mesh for the curve is tricky as we need to find the line in the faces
    def union(domains, A=inner_size, tol=1E-10):
        def body(domains):
            if isinstance(domains, str):
                if domains:
                    return '( %s )' % domains
                else:
                    return ''
            else:
                return ' || '.join(map(body, domains))

        return df.CompiledSubDomain(body(domains), A=A, tol=tol)

    lines = {
        4:
        union('near(x[1], A, tol) && near(x[2], A, tol)'),
        3:
        union('near(x[2], -x[0], tol)'),
        2:
        union('near(x[2], x[1], tol)'),
        1:
        union([
            'near(x[0], -A, tol) && near(x[2], -A, tol)',
            'near(x[1], A, tol) && near(x[0], -A, tol)',
            'near(x[1], -A, tol) && near(x[0], -A, tol)'
        ])
    }

    for tag, line in lines.items():
        # Get candidates
        facets = set(
            sum((cell.entities(1).tolist()
                 for cell in df.SubsetIterator(mesh_2d.marking_function, tag)),
                []))
        for facet in facets:
            if line.inside(df.Facet(mesh_2d, facet).midpoint().array(), True):
                facet_f[int(facet)] = 1

    return facet_f
コード例 #9
0
def tensor_components(mesh):
    ''' c00 c01 c02
            c11 c12
                c22 '''
    c00 = d.MeshFunction("double", mesh, 3)
    c01 = d.MeshFunction("double", mesh, 3)
    c02 = d.MeshFunction("double", mesh, 3)
    c11 = d.MeshFunction("double", mesh, 3)
    c12 = d.MeshFunction("double", mesh, 3)
    c22 = d.MeshFunction("double", mesh, 3)
    return c00, c01, c02, c11, c12, c22
コード例 #10
0
ファイル: setup.py プロジェクト: jakobes/Ocellaris
def mark_boundaries(simulation):
    """
    Mark the boundaries of the mesh with different numbers to be able to
    apply different boundary conditions to different regions
    """
    simulation.log.info('Creating boundary regions')

    # Create a function to mark the external facets
    mesh = simulation.data['mesh']
    marker = dolfin.MeshFunction("size_t", mesh, mesh.topology().dim() - 1)
    mesh_facet_regions = simulation.data['mesh_facet_regions']

    # Create boundary regions and let them mark the part of the
    # boundary that they belong to. They also create boundary
    # condition objects that are later used in the eq. solvers
    boundary = []
    for index, _ in enumerate(simulation.input.get_value('boundary_conditions', [], 'list(dict)')):
        part = BoundaryRegion(simulation, marker, index, mesh_facet_regions)
        boundary.append(part)

    simulation.data['boundary'] = boundary
    simulation.data['boundary_marker'] = marker
    simulation.data['boundary_by_name'] = {b.name: b for b in boundary}

    # Create a boundary measure that is aware of the marked regions
    mesh = simulation.data['mesh']
    ds = dolfin.Measure('ds', domain=mesh, subdomain_data=marker)
    simulation.data['ds'] = ds

    # Show region sizes
    one = dolfin.Constant(1)
    for region in boundary:
        length = dolfin.assemble(one * ds(region.mark_id, domain=mesh))
        pf = simulation.log.info if length > 0.0 else simulation.log.warning
        pf('    Boundary region %s has size %f' % (region.name, length))
    length0 = dolfin.assemble(one * ds(0, domain=mesh))
    pf = simulation.log.info if length0 == 0.0 else simulation.log.warning
    pf('    Boundary region UNMARKED has size %f' % length0)

    # Optionally plot boundary regions to file
    if simulation.input.get_value('output/plot_bcs', False, 'bool'):
        prefix = simulation.input.get_value('output/prefix', '', 'string')
        pfile = prefix + '_boundary_regions.xdmf'
        simulation.log.info('    Plotting boundary regions to ' 'XDMF file %r' % pfile)
        with dolfin.XDMFFile(mesh.mpi_comm(), pfile) as xdmf:
            xdmf.write(marker)
 def generate_subdomain_restriction(mesh, subdomains, subdomains_ids):
     D = mesh.topology().dim()
     # Initialize empty restriction
     restriction = mp.MeshRestriction(mesh, None)
     for d in range(D + 1):
         mesh_function_d = df.MeshFunction("bool", mesh, d)
         mesh_function_d.set_all(False)
         restriction.append(mesh_function_d)
     # Mark restriction mesh functions based on subdomain id
     for c in df.cells(mesh):
         for subdomain_id in subdomains_ids:
             if subdomains[c] == subdomain_id:
                 restriction[D][c] = True
                 for d in range(D):
                     for e in df.entities(c, d):
                         restriction[d][e] = True
     return restriction
コード例 #12
0
def spherical_shell(dim, radii, n_refinements=0):
    """
    Creates the mesh of a spherical shell using the mshr module.
    """
    assert isinstance(dim, int)
    assert dim == 2 or dim == 3

    assert isinstance(radii, (list, tuple)) and len(radii) == 2
    ri, ro = radii
    assert isinstance(ri, float) and ri > 0.
    assert isinstance(ro, float) and ro > 0.
    assert ri < ro

    assert isinstance(n_refinements, int) and n_refinements >= 0

    # mesh generation
    if dim == 2:
        center = dlfn.Point(0., 0.)
    elif dim == 3:
        center = dlfn.Point(0., 0., 0.)

    if dim == 2:
        domain = Circle(center, ro)\
            - Circle(center, ri)
        mesh = generate_mesh(domain, 75)
    elif dim == 3:
        domain = Sphere(center, ro) \
            - Sphere(center, ri)
        mesh = generate_mesh(domain, 15)

    # mesh refinement
    for i in range(n_refinements):
        mesh = dlfn.refine(mesh)

    # MeshFunction for boundaries ids
    facet_marker = dlfn.MeshFunction("size_t", mesh, mesh.topology().dim() - 1)
    facet_marker.set_all(0)

    # mark boundaries
    BoundaryMarkers = SphericalAnnulusBoundaryMarkers
    gamma_inner = CircularBoundary(mesh=mesh, radius=ri)
    gamma_inner.mark(facet_marker, BoundaryMarkers.interior_boundary.value)
    gamma_outer = CircularBoundary(mesh=mesh, radius=ro)
    gamma_outer.mark(facet_marker, BoundaryMarkers.exterior_boundary.value)

    return mesh, facet_marker
コード例 #13
0
ファイル: space.py プロジェクト: dstrelnikov/optipuls
    def _gen_ds(self):
        mesh = self.mesh
        R_laser = self.R_laser
        Z = self.Z

        top_laser_boundary = dolfin.CompiledSubDomain(
            'near(x[1], top_side) && x[0] < R_laser && on_boundary',
            top_side=Z,
            R_laser=R_laser,
        )

        top_nonlaser_boundary = dolfin.CompiledSubDomain(
            'near(x[1], top_side) && x[0]>= R_laser && on_boundary',
            top_side=Z,
            R_laser=R_laser,
        )

        bottom_boundary = dolfin.CompiledSubDomain(
            'near(x[1], bottom_side) && on_boundary',
            bottom_side=0,
        )

        symmetry_ax_boundary = dolfin.CompiledSubDomain(
            'near(x[0], right_side) && on_boundary',
            right_side=0,
        )

        # whole top boundary with no separation
        top_boundary = dolfin.CompiledSubDomain(
            'near(x[1], top_side) && on_boundary', top_side=Z)

        symmetry_ax_boundary = dolfin.CompiledSubDomain(
            'near(x[0], right_side) && on_boundary', right_side=0)

        boundary_markers = dolfin.MeshFunction('size_t', mesh,
                                               mesh.topology().dim() - 1)

        symmetry_ax_boundary.mark(boundary_markers, 0)
        top_laser_boundary.mark(boundary_markers, 1)
        top_nonlaser_boundary.mark(boundary_markers, 2)
        # side_boun.mark(boundary_markers, 3)
        bottom_boundary.mark(boundary_markers, 4)

        ds = dolfin.Measure('ds', domain=mesh, subdomain_data=boundary_markers)

        return ds
コード例 #14
0
def refine_mesh(mesh):
    """" To refine selected parts of the mesh. """
    for r in [2.5]:  #[20, 15, 10, 8]:
        print("Refining ...")
        cell_markers = df.MeshFunction("bool",
                                       mesh,
                                       dim=mesh.topology().dim() - 1)
        cell_markers.set_all(False)
        for cell in df.cells(mesh):
            # p = np.sum(np.array(cell.midpoint()[:])**2)
            if np.abs(cell.midpoint()[2]) < r:
                cell_markers[cell] = True
        mesh = df.refine(mesh, cell_markers)

        print(mesh.num_cells())
    mesh.smooth()
    return mesh
コード例 #15
0
def unitcube_geometry():
    N = 2
    mesh = dolfin.UnitCubeMesh(N, N, N)

    V_f = QuadratureSpace(mesh, 4)

    l0 = dolfin.interpolate(dolfin.Expression(("1.0", "0.0", "0.0"), degree=1),
                            V_f)
    r0 = dolfin.interpolate(dolfin.Expression(("0.0", "1.0", "0.0"), degree=1),
                            V_f)
    c0 = dolfin.interpolate(dolfin.Expression(("0.0", "0.0", "1.0"), degree=1),
                            V_f)

    crl_basis = CRLBasis(l0=l0, r0=r0, c0=c0)

    cfun = strain_markers_3d(mesh, 2)

    ffun = dolfin.MeshFunction("size_t", mesh, 2)
    ffun.set_all(0)
    fixed.mark(ffun, fixed_marker)
    free.mark(ffun, free_marker)

    marker_functions = MarkerFunctions(ffun=ffun, cfun=cfun)

    fixed_marker_ = Marker(name='fixed', value=fixed_marker, dimension=2)
    free_marker_ = Marker(name='free', value=free_marker, dimension=2)

    markers = (fixed_marker_, free_marker_)

    # Fibers
    f0 = dolfin.interpolate(dolfin.Expression(("1.0", "0.0", "0.0"), degree=1),
                            V_f)
    s0 = dolfin.interpolate(dolfin.Expression(("0.0", "1.0", "0.0"), degree=1),
                            V_f)
    n0 = dolfin.interpolate(dolfin.Expression(("0.0", "0.0", "1.0"), degree=1),
                            V_f)

    microstructure = Microstructure(f0=f0, s0=s0, n0=n0)

    geometry = Geometry(mesh=mesh,
                        markers=markers,
                        marker_functions=marker_functions,
                        microstructure=microstructure,
                        crl_basis=crl_basis)

    return geometry
コード例 #16
0
    def domain_relationship(self, A, B):
        # FIXME: this is seriously stupid and inefficient, but it works

        dom = A + B

        dom.set_subdomain(1, dom)
        dom.set_subdomain(2, A - B)
        dom.set_subdomain(3, B - A)

        mesh = mshr.generate_mesh(dom, 1)

        cf = dolfin.MeshFunction("size_t", mesh,
                                 mesh.geometry().dim(), mesh.domains())

        # cell values (subdomains) that actually show up
        cvs = frozenset(cf.array())

        return _domain_relationship_table[cvs]
コード例 #17
0
ファイル: postprocessor.py プロジェクト: jakobes/xalpost
    def load_mesh_function(self, name: str) -> dolfin.MeshFunction:
        """Lead and return a mesh function.

        There are two options, 'CellDomains' or 'FacetDomains'. Both are stored in
        'mesh.hdf5'.

        Arguments:
            name: Either 'CellDomains' or 'FacetDomains'.
        """
        msg = "Meshfunctions are stored as 'CellDomains' or 'FacetDomains'."
        assert name in ("CellDomains", "FacetDomains"), msg

        filename = calsedir / Path("mesh.hdf5")
        # with dolfin.HDF5File(dolfin.mpi_comm_world(), filename, "r") as meshfile:
        with dolfin.HDF5File(mesh.mpi_comm(), filename, "r") as meshfile:
            mesh_function = dolfin.MeshFunction()
            meshfile.read(mesh, f"/{name}")
        return mesh_function
コード例 #18
0
ファイル: ConstantBC.py プロジェクト: puncproject/ConstantBC
def relabel_bnd(bnd):
    """
    Relabels MeshFunction bnd such that boundaries are marked 1, 2, 3, etc.
    instead of arbitrary numbers. The order is preserved, and by convention the
    first boundary is the exterior boundary. The objects start at 2. The
    background (not marked) is 0.
    """
    new_bnd = bnd
    new_bnd = df.MeshFunction("size_t", bnd.mesh(), bnd.dim())
    new_bnd.set_all(0)

    old_ids = np.array([int(tag) for tag in set(bnd.array())])
    old_ids = np.sort(old_ids)[1:]
    for new_id, old_id in enumerate(old_ids, 1):
        new_bnd.array()[bnd.where_equal(old_id)] = int(new_id)

    num_objects = len(old_ids) - 1
    return new_bnd, num_objects
コード例 #19
0
def mesh1d(left, right, meshres):
    mesh = dolfin.IntervalMesh(meshres, left, right)
    # Construct of the facet markers:
    boundary = (dolfin.MeshFunction("size_t", mesh,
                                    mesh.topology().dim() - 1, 0), {})
    #boundary[0].set_all(0)
    for f in dolfin.facets(mesh):
        if dolfin.near(f.midpoint()[0], left):
            boundary[0][f] = 1  # left
            boundary[1]['inner'] = 1
        elif dolfin.near(f.midpoint()[0], right):
            boundary[0][f] = 2  # right
            boundary[1]['outer'] = 2
    # Definition of measures and normal vector:
    n = dolfin.FacetNormal(mesh)
    dx = dolfin.Measure("dx", mesh)
    ds = dolfin.Measure("ds", subdomain_data=boundary[0])
    return (mesh, boundary, n, dx, ds)
コード例 #20
0
 def __init__(self, region_material_properties, region_meshfunction, mesh):
     """Set up material property functions
 
     @param region_material_properties: A dict with key region_no, value
         MaterialProperties object for that region number
     @param region_meshfunction: A dolfin MeshFunction mapping elements to
         region numbers. If it is None, all elements are set to region 0
     @param mesh: A dolfin Mesh object relating to region_meshfunction. The
         material functions will be defined on this mesh
     """
     self.region_material_properties = region_material_properties
     # if the meshfunction is not defined then initialise to a zero mesh function
     if region_meshfunction is None:
         region_meshfunction = dolfin.MeshFunction('uint', mesh,
                                                   mesh.topology().dim())
         region_meshfunction.set_all(0)
     self.region_meshfunction = region_meshfunction
     self.mesh = mesh
コード例 #21
0
ファイル: test_shear.py プロジェクト: shumilin88/muflon
def create_domain(level, diagonal="right"):
    N = 2**level * 11
    mesh = df.UnitSquareMesh(N, N, diagonal)

    class Top(df.SubDomain):
        def inside(self, x, on_boundary):
            return on_boundary and df.near(x[1], 1.0)

    class Bottom(df.SubDomain):
        def inside(self, x, on_boundary):
            return on_boundary and df.near(x[1], 0.0)

    class Left(df.SubDomain):
        def inside(self, x, on_boundary):
            return on_boundary and df.near(x[0], 0.0)

    class Right(df.SubDomain):
        def inside(self, x, on_boundary):
            return on_boundary and df.near(x[0], 1.0)

    boundary_markers = df.MeshFunction("size_t", mesh,
                                       mesh.topology().dim() - 1)
    boundary_markers.set_all(0)
    Bottom().mark(boundary_markers, 1)
    Right().mark(boundary_markers, 2)
    Top().mark(boundary_markers, 3)
    Left().mark(boundary_markers, 4)

    class Pinpoint(df.SubDomain):
        def inside(self, x, on_boundary):
            return df.near(x[0], 0.0) and df.near(x[1], 1.0)

    class PeriodicBoundary(df.SubDomain):
        # Left boundary is "target domain" G
        def inside(self, x, on_boundary):
            return bool(on_boundary and (df.near(x[0], 0.0)))

        # Map right boundary (H) to left boundary (G)
        def map(self, x, y):
            y[0] = x[0] - 1.0
            y[1] = x[1]

    return mesh, boundary_markers, Pinpoint(), PeriodicBoundary()
コード例 #22
0
 def read_attribute_group(self, key):
     try:
         group = self.file[key]
         first = group['0']
         dim = self.dimension_dict[first.shape[0]]
         dtype = type_dict[first.dtype.kind]
         meshfunctions = []
         ii = 0
         key = f'{ii}'
         while key in group:
             dset = group[key]
             meshfunctions.append(dolfin.MeshFunction(
                 dtype, self.mesh, dim))
             meshfunctions[-1].set_values(dset[:])
             ii += 1
             key = f'{ii}'
         return meshfunctions
     except:
         raise Exception(f'Error reading attribute group: {key}')
コード例 #23
0
def mesh(Lx=1., Ly=1., grid_spacing=1. / 16, refine_depth=3, **namespace):
    m = df.RectangleMesh(df.Point(0., 0.), df.Point(Lx, Ly),
                         int(Lx / grid_spacing), int(Ly / grid_spacing))
    # x = m.coordinates()[:]

    # beta = 0.0
    # x[:, 1] = beta*x[:, 1] + (1.-beta)*Ly*(
    #     np.arctan(1.0*np.pi*((x[:, 1]-Ly)/Ly))/np.arctan(np.pi) + 1.)

    for level in range(1, refine_depth + 1):
        cell_markers = df.MeshFunction("bool", m, m.topology().dim())
        cell_markers.set_all(False)
        for cell in df.cells(m):
            y_mean = np.mean([node.x(1) for node in df.vertices(cell)])
            if y_mean < 1. / 2**level:
                cell_markers[cell] = True
        m = df.refine(m, cell_markers)

    return m
コード例 #24
0
ファイル: demo_vtk.py プロジェクト: alexdiem/pulse_adjoint
def demo_cellfunction(mesh):
    try:
        import dolfinplot as dfp
    except:
        raise IOError(
            "Misssing dolfinplot. git clone https://bitbucket.org/finsberg/dolfinplot.git"
        )
    import dolfin as df
    cfun = df.MeshFunction("size_t", mesh, 3, mesh.domains())
    V = df.FunctionSpace(mesh, "DG", 0)
    f = df.Function(V)
    f.vector()[:] = cfun.array()

    vtkfun = dfp.VTK_DolfinScalar(f)
    vtkfun.SetEdgeColor((0, 0, 0))
    focal = (mesh.coordinates().T[0].max()) / 2.0
    vtkfun.Render(view="side", dpi=300, size=(1200, 800), focal=focal)
    #vtkfun.Show()
    return vtkfun
コード例 #25
0
ファイル: ptest_qoi.py プロジェクト: mccoyMZY/hippylib
    def setUp(self):
        dl.parameters["ghost_mode"] = "shared_facet"
        ndim = 2
        nx = 10
        ny = 10
        self.mesh = dl.UnitSquareMesh(nx, ny)

        self.rank = dl.MPI.rank(self.mesh.mpi_comm())

        Vh2 = dl.FunctionSpace(self.mesh, 'Lagrange', 2)
        Vh1 = dl.FunctionSpace(self.mesh, 'Lagrange', 1)
        self.Vh = [Vh2, Vh1, Vh2]
        # Initialize Expressions
        f = dl.Constant(0.0)

        u_bdr = dl.Expression("x[1]", degree=1)
        u_bdr0 = dl.Constant(0.0)
        bc = dl.DirichletBC(self.Vh[STATE], u_bdr, u_boundary)
        bc0 = dl.DirichletBC(self.Vh[STATE], u_bdr0, u_boundary)

        def pde_varf(u, m, p):
            return dl.exp(m) * dl.inner(
                dl.nabla_grad(u), dl.nabla_grad(p)) * dl.dx - f * p * dl.dx

        self.pde = PDEVariationalProblem(self.Vh,
                                         pde_varf,
                                         bc,
                                         bc0,
                                         is_fwd_linear=True)

        GC = GammaCenter()
        marker = dl.MeshFunction("size_t", self.mesh,
                                 self.mesh.topology().dim() - 1)
        marker.set_all(0)
        GC.mark(marker, 1)
        dss = dl.Measure("dS", domain=self.mesh, subdomain_data=marker)
        n = dl.Constant((0., 1.))  #dl.FacetNormal(Vh[STATE].mesh())

        def qoi_varf(u, m):
            return dl.avg(dl.exp(m) * dl.dot(dl.grad(u), n)) * dss(1)

        self.qoi = VariationalQoi(self.Vh, qoi_varf)
コード例 #26
0
ファイル: test_boundary.py プロジェクト: C6xf/fish2eod
def complex_domain(size=15):
    """Construct a complex meshfunction representing domains.

    Simple is defined as 0 defined on the left half (x < 0.5)
    If on the right half the function is 1 if y < 0.5 and 2 if y > 0.5

    :param size: Resolution of the mesh
    :return: Domain function
    """
    mesh = df.UnitSquareMesh(size, size)
    domain = df.MeshFunction("size_t", mesh, 2)

    # make MeshFunction with left = 0 and right = 1 if lower and 2 if upper
    for c in df.cells(mesh):
        if c.midpoint()[0] > 0.5:
            if c.midpoint()[1] > 0.5:
                domain[c] = 2
            else:
                domain[c] = 1
    return domain
コード例 #27
0
def meshhdf(name):

    mesh = dolfin.Mesh()

    hdf = dolfin.HDF5File(mesh.mpi_comm(), name + "_hdf.h5", "r")
    hdf.read(mesh, "/mesh", False)

    boundary = (dolfin.MeshFunction('size_t', mesh,
                                    mesh.topology().dim() - 1, 0), {
                                        'inner': 1,
                                        'outer': 2
                                    })
    hdf.read(boundary[0], "/boundary")
    hdf.close()

    n = dolfin.FacetNormal(mesh)
    dx = dolfin.Measure("dx", domain=mesh)
    ds = dolfin.Measure("ds", domain=mesh, subdomain_data=boundary[0])

    return (mesh, boundary, n, dx, ds)
コード例 #28
0
def load_mesh_function(mesh_function, mesh, mf_dim=None):
    """
    Load the mesh function file specified by the user. The file may be
    xml, or HDF5 (assuming the current dolfin installation
    has the support).

    Parameters
    ----------

    mesh_function : str
        Name of the file that contains the desired mesh function information.

    mesh : dolfin.cpp.mesh.Mesh
        The dolfin mesh object that corresponds to the mesh function.


    Returns
    -------

    mesh_func : dolfin.cpp.mesh.MeshFunctionSizet
        This function returns a dolfin mesh function object.


    """

    mesh_func_classes = (dlf.cpp.mesh.MeshFunctionSizet,
                         dlf.cpp.mesh.MeshFunctionDouble,
                         dlf.cpp.mesh.MeshFunctionBool,
                         dlf.cpp.mesh.MeshFunctionInt)

    if isinstance(mesh_function, mesh_func_classes):
        return mesh_function

    if mesh_function[-3:] == '.h5':
        mesh_func = __load_mesh_function_hdf5(mesh_function,
                                              mesh,
                                              mf_dim=mf_dim)
    else:
        mesh_func = dlf.MeshFunction('size_t', mesh, mesh_function)

    return mesh_func
コード例 #29
0
def generate_mesh_with_cicular_subdomain(resolution, radius, plot_mesh=False):
    cx1, cy1 = 0.5, 0.5
    lx, ly = 1.0, 1.0

    # Define 2D geometry
    domain = mshr.Rectangle(dl.Point(0.0, 0.0), dl.Point(lx, ly))
    domain.set_subdomain(1, mshr.Circle(dl.Point(cx1, cy1), radius))
    cx2, cy2 = cx1 - radius / np.sqrt(8), cy1 - radius / np.sqrt(8)
    domain.set_subdomain(2, mshr.Circle(dl.Point(cx2, cy2), radius / 2))

    # Generate and plot mesh
    mesh2d = mshr.generate_mesh(domain, resolution)
    if plot_mesh:
        dl.plot(mesh2d, "2D mesh")

        class Circle1(dl.SubDomain):
            def inside(self, x, on_boundary):
                return pow(x[0] - cx1, 2) + pow(x[1] - cy1, 2) <= pow(
                    radius, 2)

        class Circle2(dl.SubDomain):
            def inside(self, x, on_boundary):
                return pow(x[0] - cx2, 2) + pow(x[1] - cy2, 2) <= pow(
                    radius / 2, 2)

        # Convert subdomains to mesh function for plotting
        mf = dl.MeshFunction("size_t", mesh2d, 2)
        mf.set_all(0)
        circle1 = Circle1()
        circle2 = Circle2()

        for c in dl.cells(mesh2d):
            if circle1.inside(c.midpoint(), True):
                mf[c.index()] = 1
            if circle2.inside(c.midpoint(), True):
                mf[c.index()] = 2

        dl.plot(mf, "Subdomains")
        # show must be called here or plot gets messed up
        # plt.show()
    return mesh2d
コード例 #30
0
def generate_polygonal_mesh(resolution,
                            ampothem,
                            nedges,
                            radius,
                            plot_mesh=False):
    """
    Sometimes segault is thrown when mshr.generate_mesh() is 
    called. This is because resolution is to low to resolve
    smaller inner-most circle.
    """
    import mshr
    vertices = get_vertices_of_polygon(ampothem, nedges)

    domain_vertices = []
    for vertex in vertices.T:
        domain_vertices.append(dl.Point(vertex[0], vertex[1]))

    domain = mshr.Polygon(domain_vertices)

    cx1, cy1 = 0.0, 0.0
    circle1 = mshr.Circle(dl.Point(cx1, cy1), radius)
    domain.set_subdomain(1, circle1)
    cx2, cy2 = cx1 - radius / np.sqrt(8), cy1 - radius / np.sqrt(8)
    circle2 = mshr.Circle(dl.Point(cx2, cy2), radius / 2)
    domain.set_subdomain(2, circle2)
    mesh = mshr.generate_mesh(domain, resolution)

    if plot_mesh:
        subdomains = dl.MeshFunction('size_t', mesh, mesh.topology().dim(), 2)
        subdomains.set_all(0)
        subdomain1 = dl.AutoSubDomain(lambda x: np.sqrt(
            (x[0] - cx1)**2 + (x[1] - cy1)**2) < radius + 1e-8)
        subdomain1.mark(subdomains, 1)
        subdomain2 = dl.AutoSubDomain(lambda x: np.sqrt(
            (x[0] - cx2)**2 + (x[1] - cy2)**2) < radius / 2 + 1e-8)
        subdomain2.mark(subdomains, 2)
        dl.plot(mesh)
        dl.plot(subdomains)
        plt.show()

    return mesh