def __init__(self, parameters, mesh, parser): super().__init__(parameters, mesh, parser) V = df.FunctionSpace( self.mesh, df.MixedElement( df.VectorElement('CG', self.mesh.ufl_cell(), parameters["fe degree solid"]), df.VectorElement('CG', self.mesh.ufl_cell(), parameters["fe degree fluid"]), df.FiniteElement('CG', self.mesh.ufl_cell(), parameters["fe degree pressure"]))) self.V = V self.two_way = True self.three_way = False if "3-way" in self.parameters["pc type"]: self.two_way = False self.three_way = True parprint("---- Problem dofs={}, h={}, solving with {} procs".format( V.dim(), mesh.hmin(), MPI.COMM_WORLD.size)) self.assembler = PoromechanicsAssembler(parameters, V, self.three_way) self.index_map = IndexSet(V, self.two_way) # Start by assembling system matrices self.assembler.assemble() self.sol = df.Function(V) self.us_nm1, self.uf_nm1, self.p_nm1 = self.sol.split(True) self.us_nm2 = self.us_nm1.copy(True) self.first_timestep = True
def _init_spaces(self): mesh = self.geometry.mesh P1 = dolfin.FiniteElement("Lagrange", mesh.ufl_cell(), 1) P2 = dolfin.VectorElement("Lagrange", mesh.ufl_cell(), 2) P3 = dolfin.VectorElement("Real", mesh.ufl_cell(), 0, 6) self.state_space = dolfin.FunctionSpace(mesh, dolfin.MixedElement([P1, P2, P3])) self.state = Function(self.state_space, name="state") self.state_test = dolfin.TestFunction(self.state_space)
def load_ellipsoid_data(): """Returns 4-tuple: mesh - the mesh, mf - MeshFunction defining boundary markers, numbering - dict of marking numbers, fibers - list of functions defining microstructure""" import dolfin mesh = dolfin.Mesh(dolfin.MPI.comm_world, "data/mesh.xml") mf = dolfin.MeshFunction("size_t", mesh, "data/facet_function.xml") numbering = {"BASE": 10, "ENDO": 30, "EPI": 40} # load fibers, sheet, cross_sheet data fiber_element = dolfin.VectorElement(family="Quadrature", cell=mesh.ufl_cell(), degree=4, quad_scheme="default") fiber_space = dolfin.FunctionSpace(mesh, fiber_element) fiber = dolfin.Function(fiber_space, "data/fiber.xml") sheet = dolfin.Function(fiber_space, "data/sheet.xml") cross_sheet = dolfin.Function(fiber_space, "data/cross_sheet.xml") fibers = [fiber, sheet, cross_sheet] return mesh, mf, numbering, fibers
def load_local_basis(h5file, lgroup, mesh, geo): if h5file.has_dataset(lgroup): # Get local bais functions local_basis_attrs = h5file.attributes(lgroup) lspace = local_basis_attrs["space"] family, order = lspace.split("_") namesstr = local_basis_attrs["names"] names = namesstr.split(":") if DOLFIN_VERSION_MAJOR > 1.6: elm = dolfin.VectorElement( family=family, cell=mesh.ufl_cell(), degree=int(order), quad_scheme="default", ) V = dolfin.FunctionSpace(mesh, elm) else: V = dolfin.VectorFunctionSpace(mesh, family, int(order)) for name in names: lb = Function(V, name=name) io_utils.read_h5file(h5file, lb, lgroup + "/{}".format(name)) setattr(geo, name, lb) else: setattr(geo, "circumferential", None) setattr(geo, "radial", None) setattr(geo, "longitudinal", None)
def stokes(self): P2 = df.VectorElement("CG", self.mesh.ufl_cell(), 2) P1 = df.FiniteElement("CG", self.mesh.ufl_cell(), 1) TH = P2 * P1 VQ = df.FunctionSpace(self.mesh, TH) mf = self.mf self.no_slip = df.Constant((0., 0)) U0_str = "4.*U_m*x[1]*(.41-x[1])/(.41*.41)" U0 = df.Expression((U0_str, "0"), U_m=self.U_m, degree=2) bc0 = df.DirichletBC(VQ.sub(0), df.Constant((0, 0)), mf, self.bc_dict["obstacle"]) bc1 = df.DirichletBC(VQ.sub(0), df.Constant((0, 0)), mf, self.bc_dict["channel_walls"]) bc2 = df.DirichletBC(VQ.sub(0), U0, mf, self.bc_dict["inlet"]) bc3 = df.DirichletBC(VQ.sub(1), df.Constant(0), mf, self.bc_dict["outlet"]) bcs = [bc0, bc1, bc2, bc3] vup = df.TestFunction(VQ) up = df.TrialFunction(VQ) up_ = df.Function(VQ) u, p = df.split(up) # Trial vu, vp = df.split(vup) # Test u_, p_ = df.split(up_) # Function holding the solution inner, grad, dx, div = df.inner, df.grad, df.dx, df.div F = self.mu*inner(grad(vu), grad(u))*dx - inner(div(vu), p)*dx \ - inner(vp, div(u))*dx df.solve(df.lhs(F) == df.rhs(F), up_, bcs=bcs) self.u_.assign(df.project(u_, self.V)) self.p_.assign(df.project(p_, self.Q)) return
def demo_vectorfunction(): try: import dolfinplot as dfp except: raise IOError( "Misssing dolfinplot. git clone https://bitbucket.org/finsberg/dolfinplot.git" ) import dolfin as df fun = df.Expression(("1", "0", "0")) element = df.VectorElement(family="Quadrature", cell=mesh.ufl_cell(), degree=2, quad_scheme="default") V = df.FunctionSpace(mesh, element) # V = df.VectorFunctionSpace(mesh, "CG", 1) g = df.interpolate(fun, V) vtkvector = dfp.VTK_DolfinVector(g, plot_mesh=False) vtkvector.SetGlyph("arrow", tipLength=0.15, tipRadius=0.05, shaftRadius=0.03) vtkvector.SetColor((1, 0, 0)) vtkvector.Render(view="side", dpi=300, size=(1200, 800)) vtkvector.Show()
def test_mat_without_dictionnary(): """FenicsPart instance initialized with only one instance of Material""" L_x, L_y = 1, 1 mesh = fe.RectangleMesh(fe.Point(0.0, 0.0), fe.Point(L_x, L_y), 10, 10) dimensions = np.array(((L_x, 0.0), (0.0, L_y))) E, nu = 1, 0.3 material = mat.Material(E, nu, "cp") rect_part = part.FenicsPart( mesh, materials=material, subdomains=None, global_dimensions=dimensions, facet_regions=None, ) elem_type = "CG" degree = 2 strain_fspace = fe.FunctionSpace( mesh, fe.VectorElement(elem_type, mesh.ufl_cell(), degree, dim=3), ) strain = fe.project(fe.Expression(("1.0+x[0]*x[0]", "0", "1.0"), degree=2), strain_fspace) stress = mat.sigma(rect_part.elasticity_tensor, strain) energy = fe.assemble(fe.inner(stress, strain) * fe.dx(rect_part.mesh)) energy_theo = E / (1 + nu) * (1 + 28 / (15 * (1 - nu))) assert energy == approx(energy_theo, rel=1e-13)
def define_function_spaces(self): """ Define the function space based on the degree(s) specified in config['formulation']['element'] and add it as member data. If the problem is specified as incompressible, a mixed function space made up of a vector and scalar function spaces is defined. Note that this differs from MechanicsProblem since there, the vector and scalar function spaces are defined separately. """ cell = self.mesh.ufl_cell() vec_degree = int(self.config['formulation']['element'][0][-1]) if vec_degree == 0: vec_family = "DG" else: vec_family = "CG" vec_element = dlf.VectorElement(vec_family, cell, vec_degree) if self.config['material']['incompressible']: scalar_degree = int(self.config['formulation']['element'][1][-1]) if scalar_degree == 0: scalar_family = "DG" else: scalar_family = "CG" scalar_element = dlf.FiniteElement(scalar_family, cell, scalar_degree) element = vec_element * scalar_element else: element = vec_element self.functionSpace = dlf.FunctionSpace(self.mesh, element) return None
def _setup_function_spaces(self): assert hasattr(self, "_mesh") # element and function space definition cell = self._mesh.ufl_cell() # taylor-hood element self._elemV = dlfn.VectorElement("CG", cell, self._parameters.velocity_degree) self._elemP = dlfn.FiniteElement("CG", cell, self._parameters.pressure_degree) self._elemT = dlfn.FiniteElement("CG", cell, self._parameters.temperature_degree) self._mixedElem = dlfn.MixedElement( [self._elemV, self._elemP, self._elemT]) self._Wh = dlfn.FunctionSpace(self._mesh, self._mixedElem) # print info message ndofs_velocity = self._Wh.sub(0).dim() ndofs_pressure = self._Wh.sub(1).dim() ndofs_temperature = self._Wh.sub(2).dim() print "DOFs velocity : ", ndofs_velocity, "\n" \ "DOFs pressure : ", ndofs_pressure, "\n" \ "DOFs temperature : ", ndofs_temperature # functions self._sol = dlfn.Function(self._Wh) self._sol0 = dlfn.Function(self._Wh) self._sol00 = dlfn.Function(self._Wh) self._v0, _, self._T0 = dlfn.split(self._sol0) self._v00, _, self._T00 = dlfn.split(self._sol00)
def define_function_spaces(self): """ Define the vector (and scalar if incompressible) function spaces based on the degrees specified in config['formulation']['element'], and add them to the instance of MechanicsProblem as member data. If the material is not incompressible, the scalar function space is set to None. """ cell = self.mesh.ufl_cell() vec_degree = int(self.config['formulation']['element'][0][-1]) if vec_degree == 0: vec_family = "DG" else: vec_family = "CG" vec_element = dlf.VectorElement(vec_family, cell, vec_degree) self.vectorSpace = dlf.FunctionSpace(self.mesh, vec_element) if self.config['material']['incompressible']: scalar_degree = int(self.config['formulation']['element'][1][-1]) if scalar_degree == 0: scalar_family = "DG" else: scalar_family = "CG" scalar_element = dlf.FiniteElement(scalar_family, cell, scalar_degree) self.scalarSpace = dlf.FunctionSpace(self.mesh, scalar_element) else: self.scalarSpace = None return None
def test_2_materials(): """FenicsPart instance initialized with only one instance of Material in the materials dictionnary""" L_x, L_y = 1, 1 mesh = fe.RectangleMesh(fe.Point(-L_x, -L_y), fe.Point(L_x, L_y), 20, 20) dimensions = np.array(((2 * L_x, 0.0), (0.0, 2 * L_y))) subdomains = fe.MeshFunction("size_t", mesh, 2) class Right_part(fe.SubDomain): def inside(self, x, on_boundary): return x[0] >= 0 - fe.DOLFIN_EPS subdomain_right = Right_part() subdomains.set_all(0) subdomain_right.mark(subdomains, 1) E_1, E_2, nu = 1, 3, 0.3 materials = {0: mat.Material(1, 0.3, "cp"), 1: mat.Material(3, 0.3, "cp")} rect_part = part.FenicsPart(mesh, materials, subdomains, dimensions) elem_type = "CG" degree = 2 strain_fspace = fe.FunctionSpace( mesh, fe.VectorElement(elem_type, mesh.ufl_cell(), degree, dim=3), ) strain = fe.project(fe.Expression(("1.0+x[0]*x[0]", "0", "1.0"), degree=2), strain_fspace) stress = mat.sigma(rect_part.elasticity_tensor, strain) energy = fe.assemble(fe.inner(stress, strain) * fe.dx(rect_part.mesh)) energy_theo = 2 * ((E_1 + E_2) / (1 + nu) * (1 + 28 / (15 * (1 - nu)))) assert energy == approx(energy_theo, rel=1e-13)
def create(self): self.metadata = { "quadrature_degree": self.deg_q, "quadrature_scheme": "default", } self.dxm = df.dx(metadata=self.metadata, subdomain_data=self.mesh_function) # solution field Ed = df.VectorElement("CG", self.mesh.ufl_cell(), degree=self.deg_d) Ee = df.FiniteElement("CG", self.mesh.ufl_cell(), degree=self.deg_d) self.V = df.FunctionSpace(self.mesh, Ed * Ee) self.Vd, self.Ve = self.V.split() self.dd, self.de = df.TrialFunctions(self.V) self.d_, self.e_ = df.TestFunctions(self.V) self.u = df.Function(self.V, name="d-e mixed space") self.d, self.e = df.split(self.u) # generic quadrature function spaces VQF, VQV, VQT = c.helper.spaces(self.mesh, self.deg_q, c.q_dim(self.constraint)) # quadrature functions Q = c.Q # inputs to the model self.q_in = OrderedDict() self.q_in[Q.EPS] = df.Function(VQV, name="current strains") self.q_in[Q.E] = df.Function( VQF, name="current nonlocal equivalent strains") self.q_in_calc = {} self.q_in_calc[Q.EPS] = c.helper.LocalProjector( self.eps(self.d), VQV, self.dxm) self.q_in_calc[Q.E] = c.helper.LocalProjector(self.e, VQF, self.dxm) # outputs of the model self.q = {} self.q[Q.SIGMA] = df.Function(VQV, name="current stresses") self.q[Q.DSIGMA_DEPS] = df.Function(VQT, name="stress-strain tangent") self.q[Q.DSIGMA_DE] = df.Function( VQV, name="stress-nonlocal-strain tangent") self.q[Q.EEQ] = df.Function(VQF, name="current (local) equivalent strain") self.q[Q.DEEQ] = df.Function(VQV, name="equivalent-strain-strain tangent") self.q_history = { Q.KAPPA: df.Function(VQF, name="current history variable kappa") } self.n = len(self.q[Q.SIGMA].vector().get_local()) // c.q_dim( self.constraint) self.nq = self.n // self.mesh.num_cells() self.ip_flags = None if self.mesh_function is not None: self.ip_flags = np.repeat(self.mesh_function.array(), self.nq)
def _generate_finite_element(self, space, **kwargs): """ Generates Finite Element for given Space. """ cell = self.domain.mesh.ufl_cell() element_type = space.element_type or "Lagrange" if space.dimension == 1 or space.dimension == 0 or space.dimension == "scalar": return dolf.FiniteElement(element_type, cell, space.order) elif space.dimension == "vector": dimension = cell.geometric_dimension() if dimension == 1: return dolf.FiniteElement(element_type, cell, space.order) return dolf.VectorElement(element_type, cell, space.order, dimension) elif space.dimension >= 2: return dolf.VectorElement(element_type, cell, space.order, space.dimension)
def get_element(self, fullname): m = self.ELEMENT_NAME_RE.fullmatch(fullname) if not m: raise ValueError("bad element name {!r}".format(fullname)) vector = m.group(1) name = m.group(2) degree = int(m.group(3)) ufl_cell = self.ufl_cell return (dolfin.FiniteElement(name, ufl_cell, degree) if not vector else dolfin.VectorElement(name, ufl_cell, degree))
def spaces(mesh, deg_q, qdim): cell = mesh.ufl_cell() q = "Quadrature" QF = df.FiniteElement(q, cell, deg_q, quad_scheme="default") QV = df.VectorElement(q, cell, deg_q, quad_scheme="default", dim=qdim) QT = df.TensorElement(q, cell, deg_q, quad_scheme="default", shape=(qdim, qdim)) return [df.FunctionSpace(mesh, Q) for Q in [QF, QV, QT]]
def init_space(self): self.mesh = mesh = dolfin.UnitSquareMesh(20, 2, "left") self.DG0_element = DG0e = dolfin.FiniteElement("DG", mesh.ufl_cell(), 0) self.DG0v_element = DG0ve = dolfin.VectorElement( "DG", mesh.ufl_cell(), 0) self.DG0 = DG0 = dolfin.FunctionSpace(mesh, DG0e) self.DG0v = DG0v = dolfin.FunctionSpace(mesh, DG0ve) self.fsr.register(DG0) self.fsr.register(DG0v)
def _init_spaces(self): mesh = self.geometry.mesh element = dolfin.VectorElement("P", mesh.ufl_cell(), 1) self.state_space = dolfin.FunctionSpace(mesh, element) self.state = dolfin.Function(self.state_space) self.state_test = dolfin.TestFunction(self.state_space) # Add penalty factor self.kappa = dolfin.Constant(1e3)
def __init__(self, sym, num, fam, deg): # Step 1. Basic coordinate properties. self.sym = sym self.num = num self.scalar_element = se = d.FiniteElement('P', num.vkl_mesh.ufl_cell(), 2) self.vector_element = ve = d.VectorElement('P', num.vkl_mesh.ufl_cell(), 2) self.tensor_element = te = d.TensorElement('P', num.vkl_mesh.ufl_cell(), 2) self.scalar_space = ss = d.FunctionSpace(num.vkl_mesh, se) self.vector_space = vs = d.FunctionSpace(num.vkl_mesh, ve) self.tensor_space = ts = d.FunctionSpace(num.vkl_mesh, te) logvc, khatc, lc = ss.tabulate_dof_coordinates().reshape((-1, 3)).T self.logv_coords, self.khat_coords, self.l_coords = logvc, khatc, lc self.cube_shape = lc.shape # Computing numbers logv = logvc khat = khatc l = lc Yony = -khat**5 * np.sqrt(l) / (num.R_E * np.sqrt(num.B0)) y, alpha = numerical_invert_Yony(Yony) self.y = y self.alpha_deg = alpha * 180 / np.pi sym_args = ( sym.logV, sym.Khat, sym.L, sym.y, sym.Cg, sym.m0, sym.B0, sym.R_E, sym.c_squared ) lit_args = ( logv, khat, l, y, num.Cg, num.m0, num.B0, num.R_E, num.c_squared ) def compute(f, with_pa=False): eff_sym_args = sym_args eff_lit_args = lit_args if with_pa: eff_sym_args += (sym.Daa, sym.Dap, sym.Dpa, sym.Dpp) eff_lit_args += self._current_pa_coeffs return sympy.lambdify(eff_sym_args, f, 'numpy')(*eff_lit_args) self.compute = compute # Useful quantities. from pwkit.cgs import evpererg self.Ekin_mev = compute(sym.Ekin) * evpererg * 1e-6
def setUp(self): self.mesh = mesh = dolfin.UnitSquareMesh(20, 2, "left") self.DG0_element = DG0e = dolfin.FiniteElement("DG", mesh.ufl_cell(), 0) self.DG0v_element = DG0ve = dolfin.VectorElement( "DG", mesh.ufl_cell(), 0) self.DG0 = DG0 = dolfin.FunctionSpace(mesh, DG0e) self.DG0v = DG0v = dolfin.FunctionSpace(mesh, DG0ve) self.fsr = fsr = FunctionSubspaceRegistry() fsr.register(DG0) fsr.register(DG0v) self.cellmid = cm = CellMidpointExpression(mesh, element=DG0ve) self.n = n = dolfin.FacetNormal(mesh) self.u = u = dolfin.Function(DG0) self.v = v = dolfin.TestFunction(DG0) u_bc = dolfin.Expression('x[0]', degree=2) x = dolfin.SpatialCoordinate(mesh) self.rho = rho = dolfin.conditional( dolfin.lt((x[0] - 0.5)**2 + (x[1] - 0.5)**2, 0.2**2), 0.0, 0.0) dot = dolfin.dot cellsize = dolfin.CellSize(mesh) self.h = h = cm('+') - cm('-') self.h_boundary = h_boundary = 2 * n * dot(x - cm, n) self.E = E = h / dot(h, h) * (u('-') - u('+')) self.E_boundary = E_boundary = h_boundary / dot( h_boundary, h_boundary) * (u - u_bc) dS = dolfin.dS eps = 1e-8 class BL(dolfin.SubDomain): def inside(self, x, on_boundary): return abs(x[0]) < eps class BR(dolfin.SubDomain): def inside(self, x, on_boundary): return abs(x[0] - 1) < eps ff = dolfin.FacetFunction('size_t', mesh, 0) BL().mark(ff, 1) BR().mark(ff, 1) ds = dolfin.Measure('ds', domain=mesh, subdomain_data=ff) self.F = (dot(E, n('+')) * v('+') * dS + dot(E, n('-')) * v('-') * dS - v * rho * dolfin.dx + dot(E_boundary, n) * v * ds(1))
def test_save(): mesh = df.UnitSquareMesh(3, 3) # exit() spaces = [ "DG_0", "DG_1", "CG_1", "CG_2", "R_0", "Quadrature_2", "Quadrature_4" ] finite_elements = [ df.FiniteElement( s.split("_")[0], mesh.ufl_cell(), int(s.split("_")[1]), quad_scheme="default", ) for s in spaces ] scalar_spaces = [df.FunctionSpace(mesh, el) for el in finite_elements] scalar_functions = [ df.Function(V, name="Scalar_{}".format(s)) for (V, s) in zip(scalar_spaces, spaces) ] vector_elements = [ df.VectorElement( s.split("_")[0], mesh.ufl_cell(), int(s.split("_")[1]), quad_scheme="default", ) for s in spaces ] vector_spaces = [df.FunctionSpace(mesh, el) for el in vector_elements] vector_functions = [ df.Function(V, name="Vector_{}".format(s)) for (V, s) in zip(vector_spaces, spaces) ] for f, space in zip(scalar_functions, spaces): name = 'test_scalar_fun_{space}'.format(space=space) ldrb.fun_to_xdmf(f, name) os.remove(name + '.xdmf') os.remove(name + '.h5') for f, space in zip(vector_functions, spaces): name = 'test_vector_fun_{space}'.format(space=space) ldrb.fun_to_xdmf(f, name) os.remove(name + '.xdmf') os.remove(name + '.h5') name = 'test_vector_fiber_{space}'.format(space=space) ldrb.fiber_to_xdmf(f, name) os.remove(name + '.xdmf') os.remove(name + '.h5')
def _init_spaces(self): logger.debug("Initialize spaces for mechanics problem") mesh = self.geometry.mesh P2 = dolfin.VectorElement("Lagrange", mesh.ufl_cell(), 2) P1 = dolfin.FiniteElement("Lagrange", mesh.ufl_cell(), 1) # P2_space = FunctionSpace(mesh, P2) # P1_space = FunctionSpace(mesh, P1) self.state_space = dolfin.FunctionSpace(mesh, P2 * P1) self.state = Function(self.state_space, name="state") self.state_test = dolfin.TestFunction(self.state_space)
def problem(): mesh = dolfin.UnitCubeMesh(MPI.comm_world, 10, 10, 10) cell = mesh.ufl_cell() vec_element = dolfin.VectorElement("Lagrange", cell, 1) # scl_element = dolfin.FiniteElement("Lagrange", cell, 1) Q = dolfin.FunctionSpace(mesh, vec_element) # Qs = dolfin.FunctionSpace(mesh, scl_element) # Coefficients v = dolfin.function.argument.TestFunction(Q) # Test function du = dolfin.function.argument.TrialFunction(Q) # Incremental displacement u = dolfin.Function(Q) # Displacement from previous iteration B = dolfin.Constant((0.0, -0.5, 0.0), cell) # Body force per unit volume T = dolfin.Constant((0.1, 0.0, 0.0), cell) # Traction force on the boundary # B, T = dolfin.Function(Q), dolfin.Function(Q) # Kinematics d = u.geometric_dimension() F = ufl.Identity(d) + grad(u) # Deformation gradient C = F.T * F # Right Cauchy-Green tensor # Invariants of deformation tensors Ic = tr(C) J = det(F) # Elasticity parameters E, nu = 10.0, 0.3 mu = dolfin.Constant(E / (2 * (1 + nu)), cell) lmbda = dolfin.Constant(E * nu / ((1 + nu) * (1 - 2 * nu)), cell) # mu, lmbda = dolfin.Function(Qs), dolfin.Function(Qs) # Stored strain energy density (compressible neo-Hookean model) psi = (mu / 2) * (Ic - 3) - mu * ln(J) + (lmbda / 2) * (ln(J))**2 # Total potential energy Pi = psi * dx - dot(B, u) * dx - dot(T, u) * ds # Compute first variation of Pi (directional derivative about u in the direction of v) F = ufl.derivative(Pi, u, v) # Compute Jacobian of F J = ufl.derivative(F, u, du) return J, F
def _setup_function_spaces(self): """ Class method setting up function spaces. """ assert hasattr(self, "_mesh") cell = self._mesh.ufl_cell() # element formulation elemU = dlfn.VectorElement("CG", cell, self._p_deg) # mixed function space self._Vh = dlfn.FunctionSpace(self._mesh, elemU) self._n_dofs = self._Vh.dim() # print info assert hasattr(self, "_n_cells") dlfn.info("Number of cells {0}, number of DoFs: {1}".format( self._n_cells, self._n_dofs))
def load_microstructure(h5file, fgroup, mesh, geo, include_sheets=True): if h5file.has_dataset(fgroup): # Get fibers fiber_attrs = h5file.attributes(fgroup) fspace = fiber_attrs["space"] if fspace is None: # Assume quadrature 4 # family = "Quadrature" # order = 4 family = "CG" order = 1 else: family, order = fspace.split("_") namesstr = fiber_attrs["names"] if namesstr is None: names = ["fiber"] else: names = namesstr.split(":") # Check that these fibers exists for name in names: fsubgroup = fgroup + f"/{name}" if not h5file.has_dataset(fsubgroup): msg = ("H5File does not have dataset {}").format(fsubgroup) logger.warning(msg) if DOLFIN_VERSION_MAJOR > 1.6: elm = dolfin.VectorElement( family=family, cell=mesh.ufl_cell(), degree=int(order), quad_scheme="default", ) V = dolfin.FunctionSpace(mesh, elm) else: V = dolfin.VectorFunctionSpace(mesh, family, int(order)) attrs = ["f0", "s0", "n0"] for i, name in enumerate(names): func = Function(V, name=name) fsubgroup = fgroup + f"/{name}" io_utils.read_h5file(h5file, func, fsubgroup) setattr(geo, attrs[i], func)
def _init_spaces(self): mesh = self.geometry.mesh V = dolfin.VectorElement("P", mesh.ufl_cell(), 2) Q = dolfin.FiniteElement("P", mesh.ufl_cell(), 1) R = dolfin.FiniteElement("Real", mesh.ufl_cell(), 0) el = dolfin.MixedElement([V, Q, R]) self.state_space = dolfin.FunctionSpace(mesh, el) self.state = dolfin.Function(self.state_space) self.state_test = dolfin.TestFunction(self.state_space) self._Vu = get_cavity_volume_form(self.geometry.mesh, u=dolfin.split(self.state)[0], xshift=self.geometry.xshift) self._V0 = dolfin.Constant(self.geometry.cavity_volume())
def create_mixed_space(mesh, k=1, augmentedTH=False, periodic_boundary=None): Pk = df.FiniteElement("CG", mesh.ufl_cell(), k) Pk1 = df.FiniteElement("CG", mesh.ufl_cell(), k + 1) FE_v = df.VectorElement(Pk1, dim=mesh.geometry().dim()) FE_p = Pk if augmentedTH: # Use enriched element for p -> augmented TH, see Boffi et al. (2011) P0 = df.FiniteElement("DG", mesh.ufl_cell(), 0) gdim = mesh.geometry().dim() assert k >= gdim - 1 # see Boffi et al. (2011, Eq. (3.1)) FE_p = df.EnrichedElement(Pk, P0) W = df.FunctionSpace(mesh, df.MixedElement([FE_v, FE_p]), constrained_domain=periodic_boundary) return W
def test_extract_nodal_CG1(self): mesh = dolfin.UnitSquareMesh(16, 16) el = dolfin.VectorElement("CG", mesh.ufl_cell(), 1) CG1 = dolfin.FunctionSpace(mesh, el) e_expr = dolfin.Expression(("x[0]-2*exp(x[1])", "x[0]*x[1]"), degree=1) x = dolfin.SpatialCoordinate(mesh) e_ufl = dolfin.as_vector((x[0] - 2 * dolfin.exp(x[1]), x[0] * x[1])) u0 = dolfin.interpolate(e_expr, CG1) u_nodal = interpolate(e_ufl, CG1) # nodal values u_proj = dolfin.project(e_ufl, CG1) # projection/averaging maxdiff = self.maxdiff self.assertLess(maxdiff(u0, u_nodal), 2 * dolfin.DOLFIN_EPS) self.assertGreater(maxdiff(u0, u_proj), 2 * dolfin.DOLFIN_EPS)
def __init__(self, d, h, ell=1., degree=1, nu=0.3, E=1.0): self.d = d self.ell = ell self.degree = degree mesh = fenics.RectangleMesh(fenics.Point(0., -0.5 * d), fenics.Point(ell, 0.5 * d), int(ell / h), int(d / h)) self.left = dolfin.CompiledSubDomain('on_boundary && x[0] <= atol', atol=1e-5 * h) self.right = dolfin.CompiledSubDomain( 'on_boundary && x[0] >= ell-atol', ell=ell, atol=1e-5 * h) element = dolfin.VectorElement('P', cell=mesh.ufl_cell(), degree=degree, dim=DIM) self.V = dolfin.FunctionSpace(mesh, element) self.lambda_ = dolfin.Constant(E * nu / (1. + nu) / (1. - 2. * nu)) self.mu = dolfin.Constant(E / 2. / (1. + nu))
def project_gradients( mesh: df.Mesh, scalar_solutions: Dict[str, df.Function], fiber_space: str = "CG_1", ) -> Dict[str, np.ndarray]: """ Calculate the gradients using projections Arguments --------- mesh : dolfin.Mesh The mesh fiber_space : str A string on the form {familiy}_{degree} which determines for what space the fibers should be calculated for. scalar_solutions: dict A dictionary with the scalar solutions that you want to compute the gradients of. """ Vv = utils.space_from_string(fiber_space, mesh, dim=3) V = utils.space_from_string(fiber_space, mesh, dim=1) data = {} V_cg = df.FunctionSpace(mesh, df.VectorElement("Lagrange", mesh.ufl_cell(), 1)) for case, scalar_solution in scalar_solutions.items(): scalar_solution_int = df.interpolate(scalar_solution, V) if case != "lv_rv": gradient_cg = df.project(df.grad(scalar_solution), V_cg, solver_type="cg") gradient = df.interpolate(gradient_cg, Vv) # Add gradient data data[case + "_gradient"] = gradient.vector().get_local() # Add scalar data if case != "apex": data[case + "_scalar"] = scalar_solution_int.vector().get_local() # Return data return data
def QuadratureSpace(mesh, degree, dim=3): """ From FEniCS version 1.6 to 2016.1 there was a change in how FunctionSpace is defined for quadrature spaces. This functions checks your dolfin version and returns the correct quadrature space :param mesh: The mesh :type mesh: :py:class:`dolfin.Mesh` :param int degree: The degree of the element :param int dim: For a mesh of topological dimension 3, dim = 1 would be a scalar function, and dim = 3 would be a vector function. :returns: The quadrature space :rtype: :py:class:`dolfin.FunctionSpace` """ import dolfin as d if d.DOLFIN_VERSION_MAJOR > 1.6: if dim == 1: element = d.FiniteElement( family="Quadrature", cell=mesh.ufl_cell(), degree=degree, quad_scheme="default", ) else: element = d.VectorElement( family="Quadrature", cell=mesh.ufl_cell(), degree=degree, quad_scheme="default", ) return d.FunctionSpace(mesh, element) else: if dim == 1: return d.FunctionSpace(mesh, "Quadrature", degree) else: return d.VectorFunctionSpace(mesh, "Quadrature", degree)