def test_print(self): from .expr import tuple_to_point mesh = dolfin.UnitSquareMesh(25, 25) muc = mesh.ufl_cell() R = ReferenceFrame('R') from sympy import exp, atan x, y = R[0], R[1] s_expr = x**2 + exp(y - DolfinConstant(0.5)) - atan(x - y) u_expr = sympy_to_ufl(R, mesh, s_expr) el1 = dolfin.FiniteElement('CG', muc, 1) W1 = dolfin.FunctionSpace(mesh, el1) u1 = dolfin.project(u_expr, W1) f = sympy.lambdify((x, y), DolfinConstant.release(s_expr)) for x0 in np.linspace(0, 1, 10): for y0 in np.linspace(0, 1, 10): a, b = f(x0, y0), u1(tuple_to_point((x0, y0))) self.assertLess(abs(a / b - 1), 0.001) s2_expr = (y * R.x + x * y * R.y).to_matrix(R)[:2, :] u2_expr = sympy_to_ufl(R, mesh, s2_expr) el2 = dolfin.FiniteElement('BDM', muc, 1) W2 = dolfin.FunctionSpace(mesh, el2) u2 = dolfin.project(u2_expr, W2) self.assertLess(abs(u2(tuple_to_point((0.2, 0.2)))[1] - 0.04), 0.001)
def create_discretization(scheme, mesh, k=1, augmentedTH=False, periodic_boundary=None, div_projection=False): # Prepare finite elements for discretization of primitive variables Pk = df.FiniteElement("Lagrange", mesh.ufl_cell(), k) Pk1 = df.FiniteElement("Lagrange", mesh.ufl_cell(), k + 1) # Define finite element for pressure FE_p = Pk if augmentedTH and scheme != "FullyDecoupled": # 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) DS = DiscretizationFactory.create(scheme, mesh, Pk, Pk, Pk1, FE_p, constrained_domain=periodic_boundary) # Function for projecting div(v) div_v = None if div_projection: div_v = df.Function(df.FunctionSpace(mesh, "DG", k)) div_v.rename("div_v", "divergence_v") return DS, div_v
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 main(): fsr = FunctionSubspaceRegistry() deg = 2 mesh = dolfin.UnitSquareMesh(100, 3) muc = mesh.ufl_cell() el_w = dolfin.FiniteElement('DG', muc, deg - 1) el_j = dolfin.FiniteElement('BDM', muc, deg) el_DG0 = dolfin.FiniteElement('DG', muc, 0) el = dolfin.MixedElement([el_w, el_j]) space = dolfin.FunctionSpace(mesh, el) DG0 = dolfin.FunctionSpace(mesh, el_DG0) fsr.register(space) facet_normal = dolfin.FacetNormal(mesh) xyz = dolfin.SpatialCoordinate(mesh) trial = dolfin.Function(space) test = dolfin.TestFunction(space) w, c = dolfin.split(trial) v, phi = dolfin.split(test) sympy_exprs = derive_exprs() exprs = { k: sympy_dolfin_printer.to_ufl(sympy_exprs['R'], mesh, v) for k, v in sympy_exprs['quantities'].items() } f = exprs['f'] w0 = dolfin.project(dolfin.conditional(dolfin.gt(xyz[0], 0.5), 1.0, 0.3), DG0) w_BC = exprs['w'] dx = dolfin.dx() form = (+v * dolfin.div(c) * dx - v * f * dx + dolfin.exp(w + w0) * dolfin.dot(phi, c) * dx + dolfin.div(phi) * w * dx - (w_BC - w0) * dolfin.dot(phi, facet_normal) * dolfin.ds() - (w0('-') - w0('+')) * dolfin.dot(phi('+'), facet_normal('+')) * dolfin.dS()) solver = NewtonSolver(form, trial, [], parameters=dict(relaxation_parameter=1.0, maximum_iterations=15, extra_iterations=10, relative_tolerance=1e-6, absolute_tolerance=1e-7)) solver.solve() with closing(XdmfPlot("out/qflop_test.xdmf", fsr)) as X: CG1 = dolfin.FunctionSpace(mesh, dolfin.FiniteElement('CG', muc, 1)) X.add('w0', 1, w0, CG1) X.add('w_c', 1, w + w0, CG1) X.add('w_e', 1, exprs['w'], CG1) X.add('f', 1, f, CG1) X.add('cx_c', 1, c[0], CG1) X.add('cx_e', 1, exprs['c'][0], CG1)
def get_arguments(dim=2, th=False, nx=2): if dim == 1: mesh = dolfin.UnitIntervalMesh(nx) elif dim == 2: mesh = dolfin.UnitSquareMesh(nx, nx) elif dim == 3: mesh = dolfin.UnitCubeMesh(nx, nx, nx) P1 = dolfin.FiniteElement("Lagrange", mesh.ufl_cell(), 1) P2 = dolfin.FiniteElement("Lagrange", mesh.ufl_cell(), 2) args = [mesh, P1, P1, P2, P1] if th: args.append(P1) return tuple(args)
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 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 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 __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 generate_function_spaces(self, order=1, use_periodic=False): r""" Generates the finite-element function spaces used with topological dimension :math:`d` set by variable ``self.top_dim``. :param order: order :math:`k` of the shape function, currently only supported are Lagrange :math:`P_1` elements. :param use_periodic: use periodic boundaries along lateral boundary (currently not supported). :type use_periodic: bool The element shape-functions available from this method are : * ``self.Q`` -- :math:`\mathcal{H}^k(\Omega)` * ``self.Q3`` -- :math:`[\mathcal{H}^k(\Omega)]^3` * ``self.V`` -- :math:`[\mathcal{H}^k(\Omega)]^d` formed using :func:`~dolfin.functions.functionspace.VectorFunctionSpace` * ``self.T`` -- :math:`[\mathcal{H}^k(\Omega)]^{d \times d}` formed using :func:`~dolfin.functions.functionspace.TensorFunctionSpace` """ s = "::: generating fundamental function spaces of order %i :::" % order print_text(s, cls=self.this) if use_periodic: self.generate_pbc() else: self.pBC = None order = 1 space = 'CG' Qe = dl.FiniteElement("CG", self.mesh.ufl_cell(), order) self.Q3 = dl.FunctionSpace(self.mesh, dl.MixedElement([Qe] * 3)) self.Q = dl.FunctionSpace(self.mesh, space, order) self.V = dl.VectorFunctionSpace(self.mesh, space, order) self.T = dl.TensorFunctionSpace(self.mesh, space, order) s = " - fundamental function spaces created - " print_text(s, cls=self.this)
def test_robin_boundary(self): frequency=50 omega = 2.*np.pi*frequency c1,c2 = [343.4,6320] gamma=8.4e-4 kappa = omega/c1 alpha=kappa*gamma Nx, Ny = 21,21; Lx, Ly = 1,1 mesh = dl.RectangleMesh(dl.Point(0., 0.), dl.Point(Lx, Ly), Nx, Ny) degree=1 P1=dl.FiniteElement('Lagrange',mesh.ufl_cell(),degree) element=dl.MixedElement([P1,P1]) function_space=dl.FunctionSpace(mesh,element) boundary_conditions=get_robin_bndry_conditions( kappa,alpha,function_space) kappa=dl.Constant(kappa) forcing=[ Forcing(kappa,'real',degree=function_space.ufl_element().degree()), Forcing(kappa,'imag',degree=function_space.ufl_element().degree())] p=run_model(kappa,forcing,function_space,boundary_conditions) error = dl.errornorm( ExactSolution(kappa,element=function_space.ufl_element()),p,) print('Error',error) assert error<=3e-2
def test_dirichlet_boundary(self): frequency=50 omega = 2.*np.pi*frequency c1,c2 = [343.4,6320] gamma=8.4e-4 kappa = omega/c1 Nx, Ny = [21,21] Lx,Ly=[1,1] # create function space mesh = dl.RectangleMesh(dl.Point(0., 0.), dl.Point(Lx, Ly), Nx, Ny) degree=1 P1=dl.FiniteElement('Lagrange',mesh.ufl_cell(),degree) element=dl.MixedElement([P1,P1]) function_space=dl.FunctionSpace(mesh,element) boundary_conditions=None kappa=dl.Constant(kappa) # do not pass element=function_space.ufl_element() # as want forcing to be a scalar pass degree instead forcing=[ Forcing(kappa,'real',degree=function_space.ufl_element().degree()), Forcing(kappa,'imag',degree=function_space.ufl_element().degree())] p=run_model(kappa,forcing,function_space,boundary_conditions) error = dl.errornorm( ExactSolution(kappa,element=function_space.ufl_element()),p) print('Error',error) assert error<=3e-2
def setUp(self): self.mesh = mesh = dolfin.UnitIntervalMesh(30) self.element = element = dolfin.FiniteElement("CG", mesh.ufl_cell(), 3) self.W = W = dolfin.FunctionSpace(mesh, element) self.u = dolfin.Function(W, name='u') self.v = dolfin.TestFunction(W) self.x = dolfin.SpatialCoordinate(mesh)[0]
def _get_rtmass(self,output_petsc=True): """ Get the square root of assembled mass matrix M using lumping. --credit to: Umberto Villa """ test = df.TestFunction(self.V) V_deg = self.V.ufl_element().degree() try: V_q_fe = df.FiniteElement('Quadrature',self.V.mesh().ufl_cell(),2*V_deg,quad_scheme='default') V_q = df.FunctionSpace(self.V.mesh(),V_q_fe) except: print('Use FiniteElement in specifying FunctionSpace after version 1.6.0!') V_q = df.FunctionSpace(self.V.mesh(), 'Quadrature', 2*self.V._FunctionSpace___degree) trial_q = df.TrialFunction(V_q) test_q = df.TestFunction(V_q) M_q = df.PETScMatrix() df.assemble(trial_q*test_q*df.dx,tensor=M_q,form_compiler_parameters={'quadrature_degree': 2*V_deg}) ones = df.interpolate(df.Constant(1.), V_q).vector() dM_q = M_q*ones M_q.zero() dM_q_2fill = ones.array() / np.sqrt(dM_q.array() ) dM_q.set_local( dM_q_2fill ) M_q.set_diagonal(dM_q) mixedM = df.PETScMatrix() df.assemble(trial_q*test*df.dx,tensor=mixedM,form_compiler_parameters={'quadrature_degree': 2*V_deg}) if output_petsc and df.has_petsc4py(): rtM = df.PETScMatrix(df.as_backend_type(mixedM).mat().matMult(df.as_backend_type(M_q).mat())) else: rtM = sps.csr_matrix(mixedM.array()*dM_q_2fill) csr_trim0(rtM,1e-12) return rtM
def generate_fibers(mesh, fiber_params): try: from fiberrules import dolfin_fiberrules except ImportError as ex: logger.error("Unable to generate fibers without fiberrules package") logger.error("This package is protected by copyright") raise ex logger.info("\nGENERATING FIBERS ...") fiber_space_name = fiber_params["fiber_space"] assert len(fiber_space_name.split("_")) == 2, \ "expected fiber_space_name in 'FamilyName_Degree' format" family, degree = fiber_space_name.split("_") if dolfin.DOLFIN_VERSION_MAJOR > 1.6: el = dolfin.FiniteElement(family=family, cell=mesh.ufl_cell(), degree=int(degree), quad_scheme="default") fiber_space = dolfin.FunctionSpace(mesh, el) else: fiber_space = dolfin.FunctionSpace(mesh, family, int(degree)) if family == "Quadrature": dolfin.parameters["form_compiler"]["quadrature_degree"] = int(degree) if dolfin.DOLFIN_VERSION_MAJOR > 2016: dolfin.parameters["form_compiler"]["representation"] = "quadrature" # There are some strange shifting in the fiberrults angles fiber_angle_epi = 90 - (-fiber_params["fiber_angle_epi"]) fiber_angle_endo = 90 - (fiber_params["fiber_angle_endo"]) sheet_angle_endo = fiber_params["sheet_angle_endo"] sheet_angle_epi = fiber_params["sheet_angle_epi"] microstructures = dolfin_fiberrules(mesh, fiber_space, fiber_angle_epi, fiber_angle_endo, sheet_angle_epi, sheet_angle_endo) microstructures[0].rename( "fiber", "epi{}_endo{}".format(fiber_params["fiber_angle_epi"], fiber_params["fiber_angle_endo"])) fields = [microstructures[0]] if fiber_params["include_sheets"]: microstructures[1].rename( "sheet", "epi{}_endo{}".format(sheet_angle_epi, sheet_angle_endo)) microstructures[2].rename( "cross_sheet", "fepi{}_fendo{}_sepi{}_sendo{}".format( fiber_params["fiber_angle_epi"], fiber_params["fiber_angle_endo"], sheet_angle_epi, sheet_angle_endo)) fields.append(microstructures[1]) fields.append(microstructures[2]) return fields
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 _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 _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 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 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 load_checkpoint( self, name: str, timestep_iterable: Iterable[int] = None, ) -> Iterator[Tuple[int, float, dolfin.Function]]: """yield tuple(float, function).""" metadata = self.load_metadata(name) _timestep_iterable = timestep_iterable timestep_iterable, time_iterable = self.load_time() # from IPython import embed; embed() # assert False if _timestep_iterable is None: _timestep_iterable = timestep_iterable if self.mesh is None: self.mesh = self.load_mesh() element_tuple = ( dolfin.interval, dolfin.triangle, dolfin.tetrahedron ) element = dolfin.FiniteElement( metadata["element_family"], element_tuple[self.mesh.geometry().dim() - 1], # zero indexed metadata["element_degree"] ) V_space = dolfin.FunctionSpace(self.mesh, element) v_func = dolfin.Function(V_space) _filename = self.casedir / Path("{name}/{name}_chk.xdmf".format(name=name)) if _filename.exists(): filename_list = [_filename] else: assert False, f"Could not open {_filename}" previous_timestep = -100 for filename in filename_list: with dolfin.XDMFFile(dolfin.MPI.comm_world, str(filename)) as fieldfile: for savad_timestep_index, timestep in enumerate(_timestep_iterable): if timestep == previous_timestep: continue previous_timestep = timestep if timestep < int(metadata["start_timestep"]): continue if timestep % int(metadata["stride_timestep"]) != 0: continue try: fieldfile.read_checkpoint(v_func, name, counter=timestep) except RuntimeError as e: LOGGER.info(f"Could not read timestep: {e}") yield time_iterable[savad_timestep_index], v_func
def test_probes(x, mesh1): el = dolfin.FiniteElement('BDM', mesh1.ufl_cell(), 2) W = dolfin.FunctionSpace(mesh1, el) z = dolfin.SpatialCoordinate(mesh1) expr = dolfin.as_vector((z[0], z[1])) w = dolfin.project(expr, W) ps = Probes(W) p = ps.probe(x) print(x, p(w), w(x)) assert (p(w) == w(x)).all()
def __init__(self, mesh, func_cont='CG', func_disc='DG', func_degree=4): """The constructor""" # mesh self.mesh = mesh # interpolating functions self.func_cont = func_cont self.func_disc = func_disc self.func_degree = func_degree # continuous function space for single scalar function self.Pn = d.FiniteElement(self.func_cont, d.interval, self.func_degree) self.S = d.FunctionSpace(self.mesh.mesh, self.Pn) # discontinuous function space for single scalar function self.dPn = d.FiniteElement(self.func_disc, d.interval, self.func_degree) self.dS = d.FunctionSpace(self.mesh.mesh, self.dPn)
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 set_FEM(self): """ Define finite element space of elliptic PDE. """ self.mesh = df.UnitSquareMesh(self.nx, self.ny) self.mpi_comm = self.mesh.mpi_comm() # boundaries self.boundaries = df.FacetFunction("size_t", self.mesh, 0) self.ds = df.ds(subdomain_data=self.boundaries) # 2. Define the finite element spaces and build mixed space try: V_fe = df.FiniteElement("CG", self.mesh.ufl_cell(), 2) L_fe = df.FiniteElement("CG", self.mesh.ufl_cell(), 2) self.V = df.FunctionSpace(self.mesh, V_fe) self.W = df.FunctionSpace(self.mesh, V_fe * L_fe) except TypeError: print('Warning: ' 'MixedFunctionSpace' ' has been deprecated in DOLFIN version 1.7.0.') print('It will be removed from version 2.0.0.') self.V = df.FunctionSpace(self.mesh, 'CG', 2) L = df.FunctionSpace(self.mesh, 'CG', 2) self.W = self.V * L # 3. Define boundary conditions bc_lagrange = df.DirichletBC( self.W.sub(1), df.Constant(0.0), "fabs(x[0])>2.0*DOLFIN_EPS & fabs(x[0]-1.0)>2.0*DOLFIN_EPS & fabs(x[1])>2.0*DOLFIN_EPS & fabs(x[1]-1.0)>2.0*DOLFIN_EPS" ) self.ess_bc = [bc_lagrange] # Create adjoint boundary conditions (homogenized forward BCs) def homogenize(bc): bc_copy = df.DirichletBC(bc) bc_copy.homogenize() return bc_copy self.adj_bcs = [homogenize(bc) for bc in self.ess_bc]
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 _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_from_h5(fname): with df.HDF5File(df.mpi_comm_world(), fname, "r") as h5file: mesh = df.Mesh() h5file.read(mesh, "mesh", True) out_list = [] if fname == 'output_u.h5': ugroup = "displacement/u{}" i = 1 while (h5file.has_dataset(ugroup.format(i))): el = df.VectorElement(df.FiniteElement('Lagrange', df.tetrahedron, 2), dim=3) V = df.FunctionSpace(mesh, el) u = df.Function(V) h5file.read(u, ugroup.format(i)) u.rename("u{}".format(i), "displacement") out_list.append(u) i += 1 elif fname == 'output_sf.h5': sfgroup = "stress/sf{}" i = 1 while (h5file.has_dataset(sfgroup.format(i))): el = df.FiniteElement('Lagrange', df.tetrahedron, 2) V = df.FunctionSpace(mesh, el) sf = df.Function(V) h5file.read(sf, sfgroup.format(i)) sf.rename("sf{}".format(i), "stress") out_list.append(sf) i += 1 return out_list #general_solver(parameters, advanced_parameters)
def OcellarisCppExpression( simulation, cpp_code, description, degree, update=True, return_updater=False, params=None, quad_degree=None, ): """ Create a dolfin.Expression and make sure it has variables like time available when executing. If update is True: all variables are updated at the start of each time step. This is useful for boundary conditions that depend on time """ def updater(timestep_number, t, dt): """ Called by simulation.hooks on the start of each time step """ # Update the expression with new values of time and similar # scalar quantities available_vars = get_vars(simulation) for name, value in available_vars.items(): if name in expression.user_parameters: expression.user_parameters[name] = value if quad_degree is not None: mesh = simulation.data['mesh'] element = dolfin.FiniteElement('Quadrature', mesh.ufl_cell(), quad_degree, quad_scheme='default') else: # Element = integer creates a CG element with the given degree element = degree # Create the expression expression = make_expression(simulation, cpp_code, description, element, params) # Return the expression. Optionally register an update each time step if update: simulation.hooks.add_pre_timestep_hook( updater, 'Update C++ expression "%s"' % description, 'Update C++ expression') if return_updater: return expression, updater else: return expression