def fenics_space(self, my_d): """ @description: Define the fenics solver space @param: None @Returns: Fenics Box structure @Modify: 2021/08/31 """ if "plugin3D" in self.det_model: self.sensor_range_confirm(my_d) m_sensor = mshr.Box(fenics.Point(self.sx_l, self.sy_l, 0), fenics.Point(self.sx_r, self.sy_r, self.fl_z)) for i in range(len(my_d.e_tr)): e_t_i = my_d.e_tr[i] elec_n = mshr.Cylinder( fenics.Point(e_t_i[0], e_t_i[1], e_t_i[3]), fenics.Point(e_t_i[0], e_t_i[1], e_t_i[4]), e_t_i[2], e_t_i[2]) m_sensor = m_sensor - elec_n elif "planar3D" in self.det_model: m_sensor = mshr.Box(fenics.Point(0, 0, 0), fenics.Point(self.fl_x, self.fl_y, self.fl_z)) else: print("sensor model is wrong") sys.exit() return m_sensor
def create_cocontinuous_mesh(self): if self.use_previously_stored_mesh: self.mesh = fe.Mesh(self.mesh_fname) print('Mesh has been loaded from file') return p = self.L * np.ones(3) geo = mesher.Box(fe.Point(0,0,0), fe.Point(p)) net = self.extrude_base_net() columns = self.create_cylindrical_columns() net += columns if self.keep_only_network: geo = net else: geo -= net print('Finished creating the geometry') self.mesh = mesher.generate_mesh(geo, self.mesh_density); print('Writing mesh to file') mesh_file = fe.File(self.mesh_fname) mesh_file << self.mesh print('Finished writing mesh to file')
def box_mesh_with_hole(point1=Point(0, 0, 0), point2=Point(2, 1, 1), cyl_cent1=Point(1, -10, 0.5), cyl_cent2=Point(1, 10, 0.5), cyl_rad=0.25, numpts=15): """ generates a 3D box mesh with tetrahedral elements with a cylindrical hole in it input ------ point1: Point coordinates in 3D corner_min of box point2: Point coordinates in 3D corner_max of box cyl_cent1: Point coordinates in 3D of center1 of Cylinder cyl_cent2: Point coordinates in 3D of center1 of Cylinder cyl_rad: Radius of cylinder npts: Number of discretization points output: ------ mesh: 3D FEniCS mesh with a cylindrical hole """ Router = mshr.Box(point1, point2) Rinner = mshr.Cylinder(cyl_cent1, cyl_cent2, cyl_rad, cyl_rad) domain = Router - Rinner mesh = mshr.generate_mesh(domain, numpts) print_mesh_stats(mesh) return mesh
def mesh_Cube(n=10): dom = mshr.Box(Point(0., 0., 0.), Point(1., 1., 1.)) gen = mshr.CSGCGALMeshGenerator3D() #gen.parameters["facet_angle"] = 30.0 #gen.parameters["facet_size"] = 0.5 #gen.parameters["edge_size"] = 0.5 gen.parameters["mesh_resolution"] = 0.01 gen.parameters["odt_optimize"] = True mesh = gen.generate(mshr.CSGCGALDomain3D(dom)) return mesh
def create_toy_mesh(): box = mshr.Box(dolfin.Point(-3, -1, -0.5), dolfin.Point(3, 1, 0.5)) c1 = mshr.Cylinder(dolfin.Point(0, 0, -2), dolfin.Point(0, 0, 2), 0.6, 0.6) b1 = mshr.Box(dolfin.Point(-2.5, -0.5, -2), dolfin.Point(-1.5, 0.5, 2)) # "triangle" t1 = mshr.Polygon([ dolfin.Point(2.5, -0.5, 0), dolfin.Point(2.5, 0.5, 0), dolfin.Point(1.5, -0.5, 0), ]) g3d = mshr.Extrude2D(t1, -2) g3d = mshr.CSGTranslation(g3d, dolfin.Point(0, 0, 1)) m = mshr.generate_mesh(box - c1 - b1 - g3d, 40, "cgal") return m.coordinates(), m.cells()
def initiate_fem(self): #define mesh #self.mesh = BoxMesh(Point(0, 0, 0), Point(self.L, self.W, self.W), 10, 3, 3) # Parameters R = self.W / 4 r = 0.08 t = self.W x = self.W / 2 + R * cos(float(t) / 180 * pi) y = self.W / 2 z = R * sin(t) # Create geometry s1 = mshr.Sphere(Point(x + self.L - 3 / 2 * self.W, y, z), r) s2 = mshr.Sphere(Point(x, y, z), r) b1 = mshr.Box(Point(0, 0, 0), Point(self.L, self.W, self.W)) b2 = mshr.Box(Point(self.L / 2 - self.w, 0, self.W / 2), Point(self.L / 2 + self.w, self.W, self.W)) geometry1 = b1 - s1 - s2 geometry2 = b1 - b2 # Create and store mesh self.mesh = mshr.generate_mesh(geometry1, 10) # use geometry1 or geometry2 #cell_markers = CellFunction("bool", mesh) #cell_markers.set_all(False) #for cell in cells(mesh): #p = cell.midpoint() #if p.x() > (self.L/2-2*self.w) and p.x() < (self.L/2-2*self.w): #cell_markers[cell] = True ## refining mesh #mesh = LocalMeshCoarsening(mesh, cell_markers) #self.mesh = mesh File('results/cracked_beam.pvd') << self.mesh #define function space self.V = VectorFunctionSpace(self.mesh, 'P', 1) #define dirichlet boundary self.bc = DirichletBC(self.V, Constant((0, 0, 0)), clamped_boundary) #define right hand side function self.f = Constant((0, 0, -self.rho * self.g)) self.T = Constant((0, 0, 0)) #define functions q = TrialFunction(self.V) # p = TrialFunction(self.V) self.d = q.geometric_dimension() v = TestFunction(self.V) aq = inner(q, v) * dx kq = -inner(sigma(q, self.lambda_, self.mu, self.d), epsilon(v)) * dx Lq = inner(self.f, v) * dx Kq, bq = assemble_system(kq, Lq, self.bc) self.Aq, dummy = assemble_system(aq, Lq, self.bc) #define the mass and stiffness matrices M = np.matrix(self.Aq.array()) print(M.shape) self.M_inv = np.linalg.inv(M) self.K = np.matrix(Kq.array()) print(self.K.shape) #define the force term c = np.matrix(bq.array()) self.cp = np.transpose(c)
def box(corner1=None, corner2=None): """A 3d rectangular prism from `corner1` to `corner2` ((0, 0, 0) to (1, 1, 1) by default)""" corner1 = corner1 or (0, 0, 0) corner2 = corner2 or (1, 1, 1) return mshr.Box(FEN.Point(corner1), FEN.Point(corner2))
def create_lv_mesh( N=13, a_endo=1.5, b_endo=0.5, c_endo=0.5, a_epi=2.0, b_epi=1.0, c_epi=1.0, center=(0.0, 0.0, 0.0), base_x=0.0, markers=None, ): r""" Create an lv-ellipsoidal mesh. An ellipsoid is given by the equation .. math:: \frac{x^2}{a} + \frac{y^2}{b} + \frac{z^2}{c} = 1 We create two ellipsoids, one for the endocardium and one for the epicardium and subtract them and then cut the base. For simplicity we assume that the longitudinal axis is in in :math:`x`-direction and as default the base is located at the :math:`x=0` plane. """ df.info("Creating LV mesh. This could take some time...") # LV # The center of the LV ellipsoid center = df.Point(*center) # Markers if markers is None: markers = default_markers() class Endo(df.SubDomain): def inside(self, x, on_boundary): return ( (x[0] - center.x()) ** 2 / a_endo ** 2 + (x[1] - center.y()) ** 2 / b_endo ** 2 + (x[2] - center.z()) ** 2 / c_endo ** 2 - 1.1 < df.DOLFIN_EPS and on_boundary ) class Base(df.SubDomain): def inside(self, x, on_boundary): return x[0] - base_x < df.DOLFIN_EPS and on_boundary class Epi(df.SubDomain): def inside(self, x, on_boundary): return ( (x[0] - center.x()) ** 2 / a_epi ** 2 + (x[1] - center.y()) ** 2 / b_epi ** 2 + (x[2] - center.z()) ** 2 / c_epi ** 2 - 0.9 > df.DOLFIN_EPS and on_boundary ) # The plane cutting the base diam = -2 * a_epi box = mshr.Box(df.Point(base_x, -diam, -diam), df.Point(diam, diam, diam)) # LV epicardium el_lv = mshr.Ellipsoid(center, a_epi, b_epi, c_epi) # LV endocardium el_lv_endo = mshr.Ellipsoid(center, a_endo, b_endo, c_endo) # LV geometry (subtract the smallest ellipsoid) lv = el_lv - el_lv_endo # LV geometry m = lv - box # Create mesh print("Generate mesh. This can take some time...") mesh = mshr.generate_mesh(m, N) ffun = df.MeshFunction("size_t", mesh, 2) ffun.set_all(0) endo = Endo() endo.mark(ffun, markers["lv"]) base = Base() base.mark(ffun, markers["base"]) epi = Epi() epi.mark(ffun, markers["epi"]) mark_facets(mesh, ffun) return geometry(mesh=mesh, ffun=ffun, markers=markers)
def create_biv_mesh( N=13, a_endo_lv=1.5, b_endo_lv=0.5, c_endo_lv=0.5, a_epi_lv=2.0, b_epi_lv=1.0, c_epi_lv=1.0, center_lv=(0.0, 0.0, 0.0), a_endo_rv=1.45, b_endo_rv=1.25, c_endo_rv=0.75, a_epi_rv=1.75, b_epi_rv=1.5, c_epi_rv=1.0, center_rv=(0.0, 0.5, 0.0), base_x=0.0, markers=None, ): r""" Create an biv-ellipsoidal mesh. An ellipsoid is given by the equation .. math:: \frac{x^2}{a} + \frac{y^2}{b} + \frac{z^2}{c} = 1 We create three ellipsoids, one for the LV and RV endocardium and one for the epicardium and subtract them and then cut the base. For simplicity we assume that the longitudinal axis is in in :math:`x`-direction and as default the base is located at the :math:`x=0` plane. """ df.info("Creating BiV mesh. This could take some time...") # The center of the LV ellipsoid center_lv = df.Point(*center_lv) # The center of the RV ellipsoid (slightly translated) center_rv = df.Point(*center_rv) # Markers if markers is None: markers = default_markers() class EndoLV(df.SubDomain): def inside(self, x, on_boundary): return ( (x[0] - center_lv.x()) ** 2 / a_endo_lv ** 2 + (x[1] - center_lv.y()) ** 2 / b_endo_lv ** 2 + (x[2] - center_lv.z()) ** 2 / c_endo_lv ** 2 - 1 < df.DOLFIN_EPS and on_boundary ) class Base(df.SubDomain): def inside(self, x, on_boundary): return x[0] - base_x < df.DOLFIN_EPS and on_boundary class EndoRV(df.SubDomain): def inside(self, x, on_boundary): return ( (x[0] - center_rv.x()) ** 2 / a_endo_rv ** 2 + (x[1] - center_rv.y()) ** 2 / b_endo_rv ** 2 + (x[2] - center_rv.z()) ** 2 / c_endo_rv ** 2 - 1 < df.DOLFIN_EPS and (x[0] - center_lv.x()) ** 2 / a_epi_lv ** 2 + (x[1] - center_lv.y()) ** 2 / b_epi_lv ** 2 + (x[2] - center_lv.z()) ** 2 / c_epi_lv ** 2 - 0.9 > df.DOLFIN_EPS ) and on_boundary class Epi(df.SubDomain): def inside(self, x, on_boundary): return ( (x[0] - center_rv.x()) ** 2 / a_epi_rv ** 2 + (x[1] - center_rv.y()) ** 2 / b_epi_rv ** 2 + (x[2] - center_rv.z()) ** 2 / c_epi_rv ** 2 - 0.9 > df.DOLFIN_EPS and (x[0] - center_lv.x()) ** 2 / a_epi_lv ** 2 + (x[1] - center_lv.y()) ** 2 / b_epi_lv ** 2 + (x[2] - center_lv.z()) ** 2 / c_epi_lv ** 2 - 0.9 > df.DOLFIN_EPS and on_boundary ) # The plane cutting the base a_epi = max(a_epi_lv, a_epi_rv) diam = -5 * a_epi box = mshr.Box(df.Point(base_x, a_epi, a_epi), df.Point(diam, diam, diam)) # Generate mesh # LV epicardium el_lv = mshr.Ellipsoid(center_lv, a_epi_lv, b_epi_lv, c_epi_lv) # LV endocardium el_lv_endo = mshr.Ellipsoid(center_lv, a_endo_lv, b_endo_lv, c_endo_lv) # LV geometry (subtract the smallest ellipsoid) lv = el_lv - el_lv_endo # LV epicardium el_rv = mshr.Ellipsoid(center_rv, a_epi_rv, b_epi_rv, c_epi_rv) # LV endocardium el_rv_endo = mshr.Ellipsoid(center_rv, a_endo_rv, b_endo_rv, c_endo_rv) # RV geometry (subtract the smallest ellipsoid) rv = el_rv - el_rv_endo - el_lv # BiV geometry m = lv + rv - box # Create mesh mesh = mshr.generate_mesh(m, N) ffun = df.MeshFunction("size_t", mesh, 2) ffun.set_all(0) endolv = EndoLV() endolv.mark(ffun, markers["lv"]) base = Base() base.mark(ffun, markers["base"]) endorv = EndoRV() endorv.mark(ffun, markers["rv"]) epi = Epi() epi.mark(ffun, markers["epi"]) mark_facets(mesh, ffun) return geometry(mesh=mesh, ffun=ffun, markers=markers)
# # m = mshr.generate_mesh(dom, 5) # m = BoxMesh(Point(0., 0., 0.), Point(1., 1., 1.), n, n, n) # K = 4 # for k in range(K): # V = FunctionSpace(m, 'Lagrange', p) # u = TrialFunction(V) # v = TestFunction(V) # M = assemble(u * v * dx) # M_diag = as_backend_type(M).mat().getDiagonal().array # print('Min of diag of M: {}'.format(M_diag.min())) # print('Dim V: {}'.format(V.dim())) # if k < K: # m = refine(m) dom = mshr.Box(Point(0., 0., 0.), Point(1., 1., 1.)) # m_orig = mshr.generate_mesh(dom,0.01) gen = mshr.CSGCGALMeshGenerator3D() #gen.parameters["facet_angle"] = 30.0 #gen.parameters["facet_size"] = 0.5 #gen.parameters["edge_size"] = 0.5 gen.parameters["mesh_resolution"] = 0.01 gen.parameters["exude_optimize"] = True m_orig = gen.generate(mshr.CSGCGALDomain3D(dom)) xf = File('mesh_orig.pvd') xf << m_orig
class Base(df.SubDomain): def inside(self, x, on_boundary): return x[0] - base_x < df.DOLFIN_EPS and on_boundary class Epi(df.SubDomain): def inside(self, x, on_boundary): return (x[0]-center.x())**2/a_epi**2 \ + (x[1]-center.y())**2/b_epi**2 \ + (x[2]-center.z())**2/c_epi**2 - 0.9 > df.DOLFIN_EPS \ and on_boundary # The plane cutting the base diam = -10.0 box = mshr.Box(df.Point(base_x, 2, 2), df.Point(diam, diam, diam)) # Generate mesh # LV epicardium el_lv = mshr.Ellipsoid(center, a_epi, b_epi, c_epi) # LV endocardium el_lv_endo = mshr.Ellipsoid(center, a_endo, b_endo, c_endo) # LV geometry (subtract the smallest ellipsoid) lv = el_lv - el_lv_endo # LV geometry m = lv - box # Create mesh mesh = mshr.generate_mesh(m, N)
from block import block_mat, block_vec, block_bc from dolfin import * from xii import * import mshr N = 10 EPS = 1E-3 R = 0.25 box_domain = mshr.Box(dolfin.Point(0, 0, 0), dolfin.Point(1, 1, 1)) _mesh = mshr.generate_mesh(box_domain, N) stokes_subdomain = dolfin.CompiledSubDomain( "sqrt((x[0]-0.5) * (x[0]-0.5) + (x[1]-0.5) * (x[1]-0.5)) < R", R=R) subdomains = MeshFunction('size_t', _mesh, _mesh.topology().dim(), 0) # Awkward marking for cell in cells(_mesh): x = cell.midpoint().array() if stokes_subdomain.inside(x, False): subdomains[cell] = 1 else: subdomains[cell] = 0 submeshes, interface, _ = mortar_meshes(subdomains, list(range(2)), strict=True, tol=EPS) stokes_domain = submeshes[0]
help="Number of loading steps to use.") parser.add_argument("--polynomial-degree", "-pd", type=int, default=2, dest="pd", choices=[1, 2, 3], help="Polynomial degree to be used for displacement.") args = parser.parse_args() # Region IDs HNBC = 0 # homogeneous Neumann BC HDBC = 10 # homogeneous Dirichlet BC INBC = 20 # inhomogeneous Neumann BC KAPPA = 1e100 if args.incompressible else args.kappa if args.generate_mesh: import mshr domain = mshr.Box(dlf.Point(), dlf.Point(10, 1, 1)) mesh_file = mshr.generate_mesh(domain, args.resolution) boundaries = dlf.MeshFunction("size_t", mesh_file, 2) boundaries.set_all(HNBC) hdbc = dlf.CompiledSubDomain("near(x[0], 0.0) && on_boundary") hdbc.mark(boundaries, HDBC) inbc = dlf.CompiledSubDomain("near(x[2], 0.0) && on_boundary") inbc.mark(boundaries, INBC) else: mesh_file = boundaries = args.mesh_file mesh = { 'mesh_file': mesh_file,