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
