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)
