def mesh_randomizer_2d(mesh, percentage, preserve_boundary=True):
"""
Randomly perturb a given mesh.
Args:
mesh: Input mesh.
percentage: Maximum perturbation in percentage of mesh.hmin().
preserve_boundary: Whether to move the vertices on the boundary.
Returns:
rmesh: The perturbed mesh.
"""
# Generate a deep copy of the mesh
rmesh = Mesh(mesh)
meshsize = rmesh.hmin()
# Randomly perturbed the mesh
radius = np.random.rand(rmesh.num_vertices()) * percentage * meshsize
theta = np.random.rand(rmesh.num_vertices()) * 2.0 * np.pi
deltax = np.zeros([rmesh.num_vertices(), 2])
deltax[:, 0] = (radius * np.sin(theta)).transpose()
deltax[:, 1] = (radius * np.cos(theta)).transpose()
# What to do with the boundary vertices
if preserve_boundary:
# Exterior means global boundary
boundary_mesh = BoundaryMesh(rmesh, "exterior")
# entity_map contains the indices of vertices on the boundary
boundary_vertices = boundary_mesh.entity_map(0).array()
deltax[boundary_vertices] = 0.0
rmesh.coordinates()[:] = rmesh.coordinates() + deltax
return rmesh
def verification_distributed_L2(list_dt, mesh_file, g0):
def speed_function(t_n):
return 1.
meshy = Mesh(mesh_file)
tips_evolution = []
for dt in list_dt:
print('dt = %e' % dt)
Nt = int(Tf / dt)
rlx = 0.8
results = initialise_results()
run_dynamic(results, meshy, u0, 'distributed', g0, dt, Nt, Ur, Gamma,
speed_function, rlx)
wx_tip = results[3][:, -1, 0]
tips_evolution.append(wx_tip)
l2s = np.empty(0)
for i, tip in enumerate(tips_evolution[:-1]):
diff = tip[i] - tip[i + 1][::2]
l2 = np.sqrt(np.sum(diff**2) / len(tips_evolution[i]))
l2s = np.append(l2s, l2)
return l2s
def __init__(self,
mesh: fe.Mesh,
density: fe.Expression,
constitutive_model: ConstitutiveModelBase,
bf: fe.Expression = fe.Expression('0', degree=0)):
self._mesh = mesh
self._density = density
self._constitutive_model = constitutive_model
self.bf = bf
element_v = fe.VectorElement("P", mesh.ufl_cell(), 1)
element_s = fe.FiniteElement("P", mesh.ufl_cell(), 1)
mixed_element = fe.MixedElement([element_v, element_v, element_s])
W = fe.FunctionSpace(mesh, mixed_element)
# Unknowns, values at previous step and test functions
w = fe.Function(W)
self.u, self.v, self.p = fe.split(w)
w0 = fe.Function(W)
self.u0, self.v0, self.p0 = fe.split(w0)
self.a0 = fe.Function(fe.FunctionSpace(mesh, element_v))
self.ut, self.vt, self.pt = fe.TestFunctions(W)
self.F = kin.def_grad(self.u)
self.F0 = kin.def_grad(self.u0)
def extrude_mesh(self, l, z_offset):
# accepts the number of layers and the length of extrusion
mesh = self.mesh
# Extrude vertices
all_coords = []
for i in linspace(0, z_offset, l):
all_coords.append(
hstack((mesh.coordinates(), i * ones((self.n_v2, 1)))))
self.global_vertices = vstack(all_coords)
# Extrude cells (tris to tetrahedra)
for i in range(l - 1):
for c in self.mesh.cells():
# Make a prism out of 2 stacked triangles
vertices = hstack((c + i * self.n_v2, c + (i + 1) * self.n_v2))
# Determine prism orientation
smallest_vertex_index = argmin(vertices)
# Map to I-ordering of Dompierre et al.
mapping = self.indirection_table[smallest_vertex_index]
# Determine which subdivision scheme to use.
if min(vertices[mapping][[1, 5]]) < min(
vertices[mapping][[2, 4]]):
local_tets = vstack((vertices[mapping][[0,1,2,5]],\
vertices[mapping][[0,1,5,4]],\
vertices[mapping][[0,4,5,3]]))
else:
local_tets = vstack((vertices[mapping][[0,1,2,4]],\
vertices[mapping][[0,4,2,5]],\
vertices[mapping][[0,4,5,3]]))
# Concatenate local tet to cell array
self.global_tets = vstack((self.global_tets, local_tets))
# Eliminate phantom initialization tet
self.global_tets = self.global_tets[1:, :]
# Query number of vertices and tets in new mesh
self.n_verts = self.global_vertices.shape[0]
self.n_tets = self.global_tets.shape[0]
# Initialize new dolfin mesh of dimension 3
self.new_mesh = Mesh()
m = MeshEditor()
m.open(self.new_mesh, 3, 3)
m.init_vertices(self.n_verts, self.n_verts)
m.init_cells(self.n_tets, self.n_tets)
# Copy vertex data into new mesh
for i, v in enumerate(self.global_vertices):
m.add_vertex(i, Point(*v))
# Copy cell data into new mesh
for j, c in enumerate(self.global_tets):
m.add_cell(j, *c)
m.close()
def __init__(self,
mesh: fe.Mesh,
constitutive_model: ConstitutiveModelBase,
u_order=1,
p_order=0):
# TODO a lot here...
element_v = fe.VectorElement("P", mesh.ufl_cell(), u_order)
element_s = fe.FiniteElement("DG", mesh.ufl_cell(), p_order)
# mixed_element = fe.MixedElement([element_v, element_v, element_s])
mixed_element = fe.MixedElement([element_v, element_s])
self.W = fe.FunctionSpace(mesh, mixed_element)
self.V, self.Q = self.W.split()
self.w = fe.Function(self.W)
self.u, self.p = fe.split(self.w)
w0 = fe.Function(self.W)
self.u0, self.p0 = fe.split(w0)
self.ut, self.pt = fe.TestFunctions(self.W)
self.F = kin.def_grad(self.u)
self.F0 = kin.def_grad(self.u0)
S_iso = constitutive_model.iso_stress(self.u)
mod_p = constitutive_model.p(self.u)
J = fe.det(self.F)
F_inv = fe.inv(self.F)
if mod_p is None:
mod_p = J**2 - 1.
else:
mod_p -= self.p
S = S_iso + J * self.p * F_inv * F_inv.T
self.d_LHS = fe.inner(fe.grad(self.ut), self.F * S) * fe.dx \
+ fe.inner(mod_p, self.pt) * fe.dx
# + fe.inner(mod_p, fe.tr(fe.nabla_grad(self.ut)*fe.inv(self.F))) * fe.dx
self.d_RHS = (fe.inner(fe.Constant((0., 0., 0.)), self.ut) * fe.dx)
def run_succession(list_Cy):
list_results = []
meshy = Mesh(mesh_file)
for Cy in list_Cy:
print('Cy = %s' % Cy)
results = run_static(meshy, u0, 'drag', Cd*Cy, rlx)
list_results.append(results)
print('')
return list_results
def unit_mesh(ht, hx):
editor = MeshEditor()
mesh = Mesh()
editor.open(mesh, "triangle", 2, 2)
editor.init_vertices(7)
editor.add_vertex(0, np.array([0.0, 0.0]))
editor.add_vertex(1, np.array([ht / 2.0, 0.0]))
editor.add_vertex(2, np.array([0.0, hx / 2.0]))
editor.add_vertex(3, np.array([ht / 2.0, hx / 2.0]))
editor.add_vertex(4, np.array([ht, hx / 2.0]))
editor.add_vertex(5, np.array([ht / 2.0, hx]))
editor.add_vertex(6, np.array([ht, hx]))
editor.init_cells(6)
editor.add_cell(0, np.array([0, 1, 3], dtype=np.uintp))
editor.add_cell(1, np.array([0, 2, 3], dtype=np.uintp))
editor.add_cell(2, np.array([1, 3, 4], dtype=np.uintp))
editor.add_cell(3, np.array([2, 3, 5], dtype=np.uintp))
editor.add_cell(4, np.array([3, 4, 6], dtype=np.uintp))
editor.add_cell(5, np.array([3, 5, 6], dtype=np.uintp))
editor.close()
mesh.order()
return mesh
def evenodd_functions_old(
omesh,
degree,
func,
width=None,
evenodd=None
):
"""Break a function into even and odd components
Required parameters:
omesh: the mesh on which the function is defined
degree: the degree of the FunctionSpace
func: the Function. This has to be something that fe.interpolate
can interpolate onto a FunctionSpace or that fe.project can
project onto a FunctionSpace.
width: the width of the domain on which func is defined. (If not
provided, this will be determined from omesh.
evenodd: the symmetries of the functions to be constructed
evenodd_symmetries(dim) is used if this is not provided
"""
SS = FunctionSpace(omesh, 'CG', degree)
dim = omesh.geometry().dim()
if width is None:
stats = mesh_stats(omesh)
width = stats['xmax']
if evenodd is None:
evenodd = evenodd_symmetries(dim)
try:
f0 = fe.interpolate(func, SS)
except TypeError:
f0 = fe.project(func, SS)
ffuncs = []
flips = evenodd_symmetries(dim)
for flip in (flips):
fmesh = Mesh(omesh)
SSf = FunctionSpace(fmesh, 'CG', degree)
ffunc = fe.interpolate(f0, SSf)
fmesh.coordinates()[:, :] = (width*flip
+ (1 - 2*flip)*fmesh.coordinates())
fmesh.bounding_box_tree().build(fmesh)
ffuncs.append(ffunc)
E = evenodd_matrix(evenodd)
components = matmul(2**(-dim)*E, ffuncs)
cs = []
for c in components:
try:
cs.append(fe.interpolate(c, SS))
except TypeError:
cs.append(fe.project(c, SS, solver_type='lu'))
return(cs)
def gaussian_mesh_randomizer(mesh, percentage, preserve_boundary=True):
"""
Randomly perturb a given mesh.
Args:
mesh: Input mesh.
percentage: Maximum perturbation in percentage of mesh.hmin().
preserve_boundary: Whether to move the vertices on the boundary.
Returns:
rmesh: The perturbed mesh.
"""
rmesh = Mesh(mesh)
deltax = (np.random.randn(rmesh.num_vertices(),
rmesh.geometry().dim()) * percentage *
rmesh.hmin())
if preserve_boundary:
boundary_mesh = BoundaryMesh(rmesh, "exterior")
boundary_vertices = boundary_mesh.entity_map(0).array()
deltax[boundary_vertices] = 0.0
rmesh.coordinates()[:] = rmesh.coordinates() + deltax
return rmesh
def __init__(self, alpha_params: GeneralizedAlphaParameters,
time_params: TimeSteppingParameters, fem_solver: FemSolver,
boundary_excitation: ExternalExcitation,
field_updates: FieldUpdates, fields: DDDbFields,
mesh: fenics.Mesh, spaces: Spaces, dddb_file_name: str,
initial_material_parameters: np.ndarray,
in_checkpoint_file_name: str, out_checkpoint_file_name: str):
super().__init__(alpha_params, time_params, fem_solver,
boundary_excitation, field_updates, fields)
self.in_checkpoint_file = XDMFCheckpointHandler(
file_name=in_checkpoint_file_name,
append_to_existing=False,
field=fields.imported_displacement_field,
field_name=fields.u_new.name())
self.out_checkpoint_file = XDMFCheckpointHandler(
file_name=out_checkpoint_file_name,
append_to_existing=False,
field=fields.u_new,
field_name=fields.u_new.name())
self.v_out_checkpoint_file = XDMFCheckpointHandler(
file_name='v_{}'.format(out_checkpoint_file_name),
append_to_existing=False,
field=fields.v_old,
field_name=fields.v_old.name())
self.a_out_checkpoint_file = XDMFCheckpointHandler(
file_name='a_{}'.format(out_checkpoint_file_name),
append_to_existing=False,
field=fields.a_old,
field_name=fields.a_old.name())
self.np_files = NPYFile(file_name=dddb_file_name)
self.tensor_space = spaces.tensor_space
self.number_of_vertices = mesh.num_vertices()
self.fields = fields
initial_values_for_optimizer = np.random.random(
self.fields.new_constitutive_relation_multiplicative_parameters.
function_space().dim() - self.fields.function_space.dim())
self.optimizer = ScipyOptimizer(
fields=self.fields,
initial_values=initial_values_for_optimizer,
fem_solver=fem_solver,
spaces=spaces)
def verification_distributed_L2(list_Nelem, g0):
profiles = []
for n_elems in list_Nelem:
print('number of elements = %d' % n_elems)
mesh_file = '../xml_files/straight_%s.xml' % n_elems
meshy = Mesh(mesh_file)
results = run_static(meshy, u0, 'distributed', g0, relaxation=0.5)
# x-displacement for all nodes
displ_x = results[3,:,0]
profiles.append(displ_x)
l2s = np.empty(0)
for i, prof in enumerate(profiles[:-1]):
diff = profiles[i] - profiles[i+1][::2]
l2 = np.sqrt(np.sum(diff**2)/len(profiles[i]))
l2s = np.append(l2s, l2)
return l2s
def validation_distributed(mesh_file):
alphas = np.linspace(0.015, 1.25, 60)
g0s = g0(alphas)
delta_ROHDE = th_y_dist(1, alphas)
delta_FEniCS = np.empty(0)
relaxation = 0.8
for G0 in g0s:
print('g0 = %f' % G0)
if G0 > 10:
relaxation = 0.5
meshy = Mesh(mesh_file)
results = run_static(meshy, u0, 'distributed', G0, relaxation=relaxation)
delta = extract_deflection(meshy, u0, results)
delta_FEniCS = np.append(delta_FEniCS, delta)
print('')
return g0s, delta_ROHDE, delta_FEniCS
from fenics import MPI, Mesh, MeshValueCollection, XDMFFile, cpp, Measure, assemble, Constant
mesh = Mesh()
mvc = MeshValueCollection("size_t", mesh, mesh.topology().dim())
with XDMFFile(MPI.comm_world, "mesh/StraightPipe/mesh.xdmf") as infile:
infile.read(mesh)
infile.read(mvc, "name_to_read")
mvc = MeshValueCollection("size_t", mesh, mesh.topology().dim() - 1)
with XDMFFile(MPI.comm_world, "mesh/StraightPipe/mf.xdmf") as infile:
infile.read(mvc, "name_to_read")
mf = cpp.mesh.MeshFunctionSizet(mesh, mvc)
# TODO: does not work well with mpi implementation, need to modify
# xmin = mesh.coordinates()[:, 0].min()
# xmax = mesh.coordinates()[:, 0].max()
# ymin = mesh.coordinates()[:, 1].min()
# ymax = mesh.coordinates()[:, 1].max()
# zmin = mesh.coordinates()[:, 2].min()
# zmax = mesh.coordinates()[:, 2].max()
# dx = Measure("dx", domain=mesh)
# volume = assemble(Constant(1) * dx)
# if MPI.rank(MPI.comm_world)==0:
# print("Mesh informations:")
# print("xmin, xmax: {}, {}".format(xmin, xmax))
# print("ymin, ymax: {}, {}".format(ymin, ymax))
# print("zmin, zmax: {}, {}".format(zmin, zmax))
# print("Number of cells: {}".format(mesh.num_cells()))
# print("Number of edges: {}".format(mesh.num_edges()))
def get_circle(): global home return Mesh(home + '/test/circle_mesh.xml.gz')
u0_ph = (0.00)*np.pi
# u0 is unitary by definition.
u0 = np.array([np.sin(u0_th)*np.cos(u0_ph),
np.sin(u0_th)*np.sin(u0_ph),
np.cos(u0_th)])
# Drag coefficient and Cauchy number
Cd = 1.2
Cy = 50
# Relaxation parameter
rlx = 0.8
# Import mesh
meshy = Mesh(mesh_file)
# Successive simulations
def run_succession(list_Cy):
list_results = []
meshy = Mesh(mesh_file)
for Cy in list_Cy:
print('Cy = %s' % Cy)
results = run_static(meshy, u0, 'drag', Cd*Cy, rlx)
list_results.append(results)
print('')
return list_results
def draw_succession(ax, list_Cy, list_results, colors):
def get_ronne_3D_10H(): global home return Mesh(home + '/antarctica/antarctica_ronne_shelf.xml')
def get_antarctica_3D_gradS_crude(): global home return Mesh(home + '/antarctica/antarctica_3D_gradS_mesh_crude.xml')
def get_greenland_coarse(): global home return Mesh(home + '/greenland/greenland_coarse_mesh.xml')
def get_antarctica_3D_gradS_detailed(): global home return Mesh(home + '/antarctica/antarctica_3D_gradS_mesh_detailed.xml')
def get_greenland_detailed(): global home return Mesh(home + '/greenland/greenland_detailed_mesh.xml')
from gmsh_interface import GmshInterface
g = GmshInterface("../geo/simple_muscle_3d.geo")
g.set_parameter("lc",0.1)
g.generate_xml("../geo/test.xml")
from fenics import Mesh, plot
import matplotlib.pyplot as plt
mesh = Mesh("../geo/test.xml")
plot(mesh)
plt.show()
def get_greenland_3D_5H(): global home return Mesh(home + '/greenland/greenland_3D_5H_mesh.xml')
def get_greenland_2D_5H_sealevel(): global home return Mesh(home + '/greenland/greenland_2D_5H_sealevel.xml')
def get_antarctica_3D_10k(): global home return Mesh(home + '/antarctica/antarctica_3D_10k.xml')
def get_antarctica_coarse(): global home return Mesh(home + '/antarctica/antarctica_50H_5l.xml')
def get_greenland_medium(): global home return Mesh(home + '/greenland/greenland_medium_mesh.xml')
#from dolfin import Mesh
from fenics import Mesh
import os
if not os.path.isfile("mesh/Skewed2D.xml"):
try:
os.system("gmsh mesh/Skewed2D.geo -2 -o mesh/Skewed2D.msh")
os.system("meshio-convert mesh/Skewed2D.msh mesh/Skewed2D.xml"
) # seems like it does not work properly
os.system("rm mesh/Skewed2D.msh")
except RuntimeError:
raise "Gmsh is required to run this demo"
# Create a mesh
mesh = Mesh("mesh/Skewed2D.xml")
# Specify boundary conditions
tol = 1e-8
L = 1.0
def inlet(x, on_bnd):
return x[0] < tol and on_bnd
def outlet(x, on_bnd):
return x[0] > L - tol and on_bnd
def walls(x, on_bnd):
def get_antarctica_2D_medium(): global home return Mesh(home + '/antarctica/antarctica_2D_medium_mesh.xml')
VectorFunctionSpace, MPI, mpi_comm_world
import sys
import numpy as np
import time as timer
from fenicstools import Probes
# Local import
from stress_tensor import *
from common import *
from weak_form import *
# Set output from FEniCS
set_log_active(False)
# Set ut problem
mesh = Mesh(
path.join(rel_path, "mesh", "von_karman_street_FSI_structure_refine2.xml"))
# Function space
V = VectorFunctionSpace(mesh, "CG", 2)
VV = V * V
# Get the point [0.2,0.6] at the end of bar
for coord in mesh.coordinates():
if coord[0] == 0.6 and (0.2 - DOLFIN_EPS <= coord[1] <= 0.2 + DOLFIN_EPS):
#print coord
break
BarLeftSide = AutoSubDomain(lambda x: "on_boundary" and \
(((x[0] - 0.2) * (x[0] - 0.2) +
(x[1] - 0.2) * (x[1] - 0.2) < 0.0505*0.0505 )
and x[1] >= 0.19 \
def get_antarctica_3D_100H(): global home return Mesh(home + '/antarctica/antarctica_3D_100H_mesh.xml')
