Exemple #1
0
 def inside(self, x, on_boundary):
     if between(x[1], [0, self.h1]):
         xx = (self.b / self.h1) * x[1] + self.L1
         x_cond = between(x[0], [self.L1, xx])
         return x_cond
     else:
         return False
Exemple #2
0
 def inside(self, x, on_boundary):
     if near(x[1], self.h1):
         x_top = between(x[0], [self.L1, self.L1 + self.b])
         return on_boundary and x_top
     elif near(x[0], self.L1):
         y_left = between(x[1], [0., self.h1])
         return on_boundary and y_left
Exemple #3
0
    def inside(self, x, on_boundary):
        cond1 = x[0] > -self.a
        cond2 = x[0] < -self.a - self.f + self.L
        if (cond1 and cond2):
            if between(x[0], [-self.a, -self.fx]):
                yy = np.sqrt((self.b**2) * (1 - ((x[1] / self.a)**2)))
                return between(x[1], [-yy, +yy])

            else:
                return between(x[1], [-self.h / 2, +self.h / 2])
        else:
            return False
Exemple #4
0
    def inside(self, x, on_boundary):
        y_top = near(x[1], self.h + self.h)
        y_bot = near(x[1], -self.h)
        y_cond = y_top or y_bot

        x_right = near(x[0], self.L + self.L)
        x_left = near(x[0], self.L) and not between(x[1], [0., self.h])
        x_cond = x_right or x_left

        cond = y_cond or x_cond

        return on_boundary and cond
 def inside(self, x, on_boundary):
     if param.tab_p_location == 't':
         return df.near(x[1], 1.0) and \
             df.between(x[0], (param.tab_p_centre - param.L_tab_p / 2,
                               param.tab_p_centre + param.L_tab_p / 2)
                        )
     elif param.tab_p_location == 'b':
         return df.near(x[1], 0.0) and \
             df.between(x[0], (param.tab_p_centre - param.L_tab_p / 2,
                               param.tab_p_centre + param.L_tab_p / 2)
                        )
     elif param.tab_p_location == 'l':
         return df.near(x[0], 0.0) and \
             df.between(x[1], (param.tab_p_centre - param.L_tab_p / 2,
                               param.tab_p_centre + param.L_tab_p / 2)
                        )
     elif param.tab_p_location == 'r':
         return df.near(x[0], param.Ly) and \
             df.between(x[1], (param.tab_p_centre - param.L_tab_p / 2,
                               param.tab_p_centre + param.L_tab_p / 2)
                        )
     else:
         raise ValueError("Pos. tab location must be one of "
                          "t, b, l, r!")
Exemple #6
0
 def inside(self, x, on_boundary):
     if np.abs(self.electrode.angle) > 1e-16:
         if self.point_inside_polygon(x[0], x[1]):
             # print(x, "True without modification.")
             return True
         elif self.point_inside_polygon(x[0]+self.tol,x[1]) or \
              self.point_inside_polygon(x[0]+self.tol,x[1]+self.tol) or \
              self.point_inside_polygon(x[0]+self.tol,x[1]-self.tol) or \
              self.point_inside_polygon(x[0]-self.tol,x[1]) or \
              self.point_inside_polygon(x[0]-self.tol,x[1]+self.tol) or \
              self.point_inside_polygon(x[0]-self.tol,x[1]-self.tol) or \
              self.point_inside_polygon(x[0],x[1]+self.tol) or \
              self.point_inside_polygon(x[0],x[1]-self.tol):
             return True
         else:
             return False
     else:
         return ( self.point_inside_polygon(x[0], x[1]) \
             and dolfin.between(x[2], (self.zs[0], self.zs[1])))
Exemple #7
0
 def inside(self, x, on_boundary):
     #-----------------------------------------------------------------------------------
     if self.tDim == 1:
         return not(df.between(x[0], \
                    (self.pmlOpt['minLimit'][0],self.pmlOpt['maxLimit'][0])))
     if self.tDim == 2:
         return not(df.between(x[0], \
                    (self.pmlOpt['minLimit'][0],self.pmlOpt['maxLimit'][0])) \
                           and \
                           df.between(x[1], \
                           (self.pmlOpt['minLimit'][1],self.pmlOpt['maxLimit'][1])))
     if self.tDim == 3:
         return not(df.between(x[0], \
                    (self.pmlOpt['minLimit'][0],self.pmlOpt['maxLimit'][0])) \
                           and \
                           df.between(x[1], \
                           (self.pmlOpt['minLimit'][1],self.pmlOpt['maxLimit'][1]))
                           and \
                           df.between(x[2], \
                           (self.pmlOpt['minLimit'][2],self.pmlOpt['maxLimit'][2])))
 def inside(self, x, on_boundary):
     return df.between(x[0]**2 + x[1]**2,
                       (0, 1)) and df.between(x[1], (0, 1))
Exemple #9
0
 def inside(self, x, on_boundary):
     x_right = between(x[0], [self.L1, self.L1 + self.b])
     y_right = between(x[1], [0, self.h1])
     cond = x_right and y_right
     return on_boundary and cond
Exemple #10
0
 def inside(self, x, on_boundary):
     return dolfin.between(x[0]**2 + x[1]**2 + x[2]**2, (0, 3.**2))
Exemple #11
0
 def inside(self, x, on_boundary):
     return between(x[1], (0.5, 0.7)) and between(x[0], (0.2, 1.0))
Exemple #12
0
 def inside(self, x, on_boundary):
     x_cond = near(x[0], self.L)
     y_cond = between(x[1], [0., self.h])
     cond = x_cond and y_cond
     return on_boundary and cond
Exemple #13
0
 def inside(self, x, on_boundary):
     return on_boundary and between(x[0], [self.L, self.L + self.c])
Exemple #14
0
 def inside(self, x, on_boundary):
     return (between(x[1], (0.5, 0.7)) and between(x[0], (0.2, 1.0)))
Exemple #15
0
def test_3d():
    x0, y0, z0 = np.zeros(3)
    x1, y1, z1 = np.ones(3)

    points = [(x0, y0, z0),
              (x1, y0, z0),
              (x1, y1, z0),
              (x0, y1, z0),
              (x0, y0, z1),
              (x1, y0, z1),
              (x1, y1, z1),
              (x0, y1, z1)]

    # Add points
    model = gmsh.model
    gmsh.initialize([])
    
    gmsh.option.setNumber("General.Terminal", 1)

    # Add components to model
    for point in points: model.geo.addPoint(*point)

    lines = [(1, 2), (2, 3), (3, 4), (4, 1),
             (5, 6), (6, 7), (7, 8), (8, 5),
             (1, 5), (2, 6), (3, 7), (4, 8)]

    lines_ = []
    for lidx, line in enumerate(lines, 1):
        lines_.append(model.geo.addLine(*line, tag=lidx))

    surfs = [(1, 2, 3, 4), (5, 6, 7, 8),
             (1, 10, -5, -9), (2, 11, -6, -10),
             (11, 7, -12, -3), (12, 8, -9, -4)]

    plane_tags = []
    for sidx, surf in enumerate(surfs, 1):
        tag = model.geo.addCurveLoop(surf, tag=sidx)
        plane_tags.append(model.geo.addPlaneSurface([tag]))
        
    surface_loop = [model.geo.addSurfaceLoop(plane_tags)]
    volume = model.geo.addVolume(surface_loop)

    model.addPhysicalGroup(1, lines_, 23)

    model.addPhysicalGroup(2, plane_tags[0:3], 2)
    model.addPhysicalGroup(2, plane_tags[3:4], 32)
    model.addPhysicalGroup(2, plane_tags[4:5], 22)
        
    model.addPhysicalGroup(3, [volume], 42)

    model.geo.synchronize()

    # gmsh.fltk.initialize()
    # gmsh.fltk.run()
    
    model.mesh.generate(3)

    # Finally
    mesh, foos = mesh_from_gmshModel(model, include_mesh_functions=-1)

    # We get the cells and nodes right
    elm, nodes = model.mesh.getElementsByType(4)
    assert len(elm) == mesh.num_cells()
    assert len(set(nodes)) == mesh.num_vertices()
    # We have all the mappings
    assert set((1, 2, 3)) == set(foos.keys())

    # Volume
    vol_tags = np.unique(foos[3].array())
    assert len(vol_tags) == 1
    assert vol_tags[0] == 42

    coords = mesh.coordinates()

    # Surfaces
    mesh.init(2, 0)
    f2v = mesh.topology()(2, 0)
    for f in range(mesh.num_entities(2)):
        mid = np.mean(coords[f2v(f)], axis=0)
        if foos[2][f] == 2:
            assert df.near(mid[1], 0) or df.near(mid[2]*(1-mid[2]), 0)
        elif foos[2][f] == 32:
            assert df.near(mid[0], 1)
        elif foos[2][f] == 22:
            assert df.near(mid[1], 1)
        else:
            assert foos[2][f] == 0

    okay_edge = lambda mid: np.array([[df.near(xi, 0) for xi in mid],
                                      [df.near(xi, 1) for xi in mid],
                                      [0 < xi < 1 for xi in mid]])
                                      
    
    # Edge
    mesh.init(1)
    e2v = mesh.topology()(1, 0)
    for edge in range(mesh.num_entities(1)):
        if foos[1][edge] == 23:
            mid = np.mean(coords[e2v(edge)], axis=0)
            assert all([df.near(xi, 0) or df.near(xi, 1) or df.between(xi, (0, 1)) for xi in mid])

    
    gmsh.clear()
Exemple #16
0
def test_2d():
    x0, y0 = np.zeros(2)
    x1, y1 = np.ones(2)

    points = [(x0, y0, 0),
              (x1, y0, 0),
              (x1, y1, 0),
              (x0, y1, 0)]

    # Add points
    model = gmsh.model
    gmsh.initialize([])

    gmsh.option.setNumber("General.Terminal", 1)

    # # Add components to model
    for point in points: model.geo.addPoint(*point)
    #      3<
    # 4v   5/     2^
    #      1>
    lines_ = [(1, 2), (2, 3), (3, 4), (4, 1), (1, 3)]
    lines = []    
    for lidx, line in enumerate(lines_, 1):
        lines.append(model.geo.addLine(*line, tag=lidx))

    surfs = [(1, 2, -5), (5, 3, 4)]

    plane_tags = []
    for sidx, surf in enumerate(surfs, 1):
        tag = model.geo.addCurveLoop(surf, tag=sidx)
        plane_tags.append(model.geo.addPlaneSurface([tag]))

    model.addPhysicalGroup(2, plane_tags[0:1], 2)  # y < x
    model.addPhysicalGroup(2, plane_tags[1:2], 3)  # y > x
        
    model.addPhysicalGroup(1, lines[0:2], 22)  # y = 0, x = 1
    model.addPhysicalGroup(1, lines[2:4], 42)  # y = 1, x = 0

    model.addPhysicalGroup(0, [1, 2, 3, 4], 3)  

    model.geo.synchronize()

    model.mesh.generate(2)

    # Finally
    mesh, foos = mesh_from_gmshModel(model, include_mesh_functions=-1)
    
    # We get the cells and nodes right
    elm, nodes = model.mesh.getElementsByType(2)
    assert len(elm) == mesh.num_cells()
    assert len(set(nodes)) == mesh.num_vertices()

    # We have all the mappings
    assert set((0, 1, 2)) == set(foos.keys())

    coords = mesh.coordinates()
    # Cell f
    for cell in df.cells(mesh):
        x, y = cell.midpoint().array()[:2]
        if foos[2][cell] == 2:
            assert y < x
        else:
            assert foos[2][cell] == 3, foos[2][cell]
            assert x < y

    # Facet f
    mesh.init(1)
    f2v = mesh.topology()(1, 0)
    for facet in range(mesh.num_entities(1)):
        x, y = np.mean(coords[f2v(facet)], axis=0)[:2]
        if foos[1][facet] == 22:
            assert df.near(y, 0) or df.near(x, 1)
        
        elif foos[1][facet] == 42:
            assert df.near(y, 1) or df.near(x, 0)
        else:
            assert df.between(x, (0, 1)) and df.between(y, (0, 1))
            assert foos[1][facet] == 0

    # Vertex
    vf = foos[0].array()
    nodes, = np.where(vf == 3)
    assert len(nodes) == 4

    coords = coords[nodes]
    for x in coords:
        assert df.near(x[0], 0) or df.near(x[0], 1)
        assert df.near(x[1], 0) or df.near(x[1], 1)
    
    gmsh.clear()
Exemple #17
0
 def inside(self, x, on_boundary):
     return near(x[0], self.xmax) and between(x[1], (self.ymin, self.ymax))
Exemple #18
0
 def inside(self, x, on_boundary):
     return on_boundary and between(x[0], [0, self.L])
Exemple #19
0
 def inside(self, x, on_boundary):
     return (between(x[0], (-self.w_wg / 2, self.w_wg / 2))
             and between(x[1], (-self.h_wg / 2, self.h_wg / 2)))
Exemple #20
0
 def inside(self,x,on_boundary):
     return dolfin.between(x[0]**2+x[1]**2+x[2]**2,(0,3.**2))
Exemple #21
0
 def inside(self,x,on_boundary):
     return df.between(x[0]**2+x[1]**2,(0,1)) and df.between(x[1],(0,1))   
Exemple #22
0
 def inside(self, x, on_boundary):
     x_cond = between(x[0], [self.L, self.L + self.c])
     y_cond = between(x[1], [0., self.h])
     return x_cond and y_cond
Exemple #23
0
 def inside(self, x, on_boundary):
     return (dolfin.between(x[0], (self.minxy[0], self.maxxy[0]))
             and
             dolfin.between(x[1], (self.minxy[1], self.maxxy[1])))
Exemple #24
0
 def inside(self, x, on_boundary):
     return between(x[0], [self.b, self.b + self.o * self.L])
Exemple #25
0
 def inside(self, x, on_boundary):
     return (dolfin.between(
         x[2], (self.boundary_dielectric, self.boundary_z_max)))