def create_simple_mesh(self):
#domain = mesher.Circle(fe.Point(0,0), 1)
#mesh = mesher.generate_mesh(domain, 64)
'''
domain_vertices = [\
fe.Point(0.0, 0.0),\
fe.Point(10.0, 0.0),\
fe.Point(10.0, 2.0),\
fe.Point(8.0, 2.0),\
fe.Point(7.5, 1.0),\
fe.Point(2.5, 1.0),\
fe.Point(2.0, 4.0),\
fe.Point(0.0, 4.0),\
fe.Point(0.0, 0.0)]
geo = mesher.Polygon(domain_vertices)
self.mesh = mesher.generate_mesh(geo, 64);
'''
print('Creating simple mesh')
nx = ny = 8
if self.dimension == 1:
self.mesh = fe.UnitIntervalMesh(nx)
#self.mesh = fe.IntervalMesh(nx,-4, 4)
if self.dimension == 2:
self.mesh = fe.UnitSquareMesh(nx, ny)
'''
def test_fenics_to_numpy_function():
# Functions in DG0 have nodes at centers of finite element cells
mesh = fenics.UnitIntervalMesh(10)
V = fenics.FunctionSpace(mesh, "DG", 0)
test_input = fenics.interpolate(fenics.Expression("x[0]", degree=1), V)
expected = numpy.linspace(0.05, 0.95, num=10)
assert numpy.allclose(fenics_to_numpy(test_input), expected)
def test_numpy_to_fenics_function():
test_input = numpy.linspace(0.05, 0.95, num=10)
mesh = fenics.UnitIntervalMesh(10)
V = fenics.FunctionSpace(mesh, "DG", 0)
template = fenics.Function(V)
fenics_test_input = numpy_to_fenics(test_input, template)
expected = fenics.interpolate(fenics.Expression("x[0]", degree=1), V)
assert numpy.allclose(fenics_test_input.vector().get_local(),
expected.vector().get_local())
def test_formulation_1_extrap_1_material():
'''
Test function formulation() with 1 extrinsic trap
and 1 material
'''
dt = 1
traps = [{
"energy": 1,
"materials": [1],
"type": "extrinsic"
}]
materials = [{
"alpha": 1,
"beta": 2,
"density": 3,
"borders": [0, 1],
"E_diff": 4,
"D_0": 5,
"id": 1
}]
mesh = fenics.UnitIntervalMesh(10)
V = fenics.VectorFunctionSpace(mesh, 'P', 1, 2)
W = fenics.FunctionSpace(mesh, 'P', 1)
u = fenics.Function(V)
u_n = fenics.Function(V)
v = fenics.TestFunction(V)
n = fenics.interpolate(fenics.Expression('1', degree=0), W)
solutions = list(fenics.split(u))
previous_solutions = list(fenics.split(u_n))
testfunctions = list(fenics.split(v))
extrinsic_traps = [n]
mf = fenics.MeshFunction('size_t', mesh, 1, 1)
dx = fenics.dx(subdomain_data=mf)
temp = fenics.Expression("300", degree=0)
flux_ = fenics.Expression("10000", degree=0)
F, expressions = FESTIM.formulation(
traps, extrinsic_traps, solutions, testfunctions,
previous_solutions, dt, dx, materials, temp, flux_)
expected_form = ((solutions[0] - previous_solutions[0]) / dt) * \
testfunctions[0]*dx
expected_form += 5 * fenics.exp(-4/8.6e-5/temp) * \
fenics.dot(
fenics.grad(solutions[0]), fenics.grad(testfunctions[0]))*dx(1)
expected_form += -flux_*testfunctions[0]*dx + \
((solutions[1] - previous_solutions[1]) / dt) * \
testfunctions[1]*dx
expected_form += - 5 * fenics.exp(-4/8.6e-5/temp)/1/1/2 * \
solutions[0] * (extrinsic_traps[0] - solutions[1]) * \
testfunctions[1]*dx(1)
expected_form += 1e13*fenics.exp(-1/8.6e-5/temp)*solutions[1] * \
testfunctions[1]*dx(1)
expected_form += ((solutions[1] - previous_solutions[1]) / dt) * \
testfunctions[0]*dx
assert expected_form.equals(F) is True
def test_jax_to_fenics_function(test_input, expected_expr):
mesh = fenics.UnitIntervalMesh(10)
V = fenics.FunctionSpace(mesh, "DG", 0)
template = fenics.Function(V)
fenics_test_input = numpy_to_fenics(test_input, template)
expected = fenics.interpolate(fenics.Expression(expected_expr, degree=1), V)
assert numpy.allclose(
fenics_test_input.vector().get_local(), expected.vector().get_local()
)
def test_fenics_to_numpy_mixed_function():
# Functions in DG0 have nodes at centers of finite element cells
mesh = fenics.UnitIntervalMesh(10)
vec_dim = 4
V = fenics.VectorFunctionSpace(mesh, "DG", 0, dim=vec_dim)
test_input = fenics.interpolate(
fenics.Expression(vec_dim * ("x[0]", ), element=V.ufl_element()), V)
expected = numpy.linspace(0.05, 0.95, num=10)
expected = numpy.reshape(numpy.tile(expected, (4, 1)).T, V.dim())
assert numpy.allclose(fenics_to_numpy(test_input), expected)
def test_1d_velocity_unit__ci__():
mesh = fenics.UnitIntervalMesh(5)
V = fenics.VectorFunctionSpace(mesh, "P", 1)
u = fenics.Function(V)
bc = fenics.DirichletBC(V, [10.0], "x[0] < 0.5")
print(bc.get_boundary_values())
def test_1d_velocity():
mesh = fenics.UnitIntervalMesh(fenics.dolfin.mpi_comm_world(), 5)
V = fenics.VectorFunctionSpace(mesh, "P", 1)
u = fenics.Function(V)
bc = fenics.DirichletBC(V, [10.0], "x[0] < 0.5")
print(bc.get_boundary_values())
def stefan_problem_solidify(Ste=0.125,
theta_h=0.01,
theta_c=-1.,
theta_f=0.,
r=0.01,
dt=0.01,
end_time=1.,
nlp_absolute_tolerance=1.e-4,
initial_uniform_cell_count=100,
automatic_jacobian=False):
mesh = fenics.UnitIntervalMesh(initial_uniform_cell_count)
w, mesh = phaseflow.run(
output_dir='output/convergence_stefan_problem_solidify/dt' + str(dt) +
'/dx' + str(1. / float(initial_uniform_cell_count)) + '/',
Pr=1.,
Ste=Ste,
g=[0.],
mesh=mesh,
initial_values_expression=("0.", "0.",
"(" + str(theta_c) + " - " + str(theta_h) +
")*near(x[0], 0.) + " + str(theta_h)),
boundary_conditions=[{
'subspace': 0,
'value_expression': [0.],
'degree': 3,
'location_expression': "near(x[0], 0.) | near(x[0], 1.)",
'method': "topological"
}, {
'subspace': 2,
'value_expression': theta_c,
'degree': 2,
'location_expression': "near(x[0], 0.)",
'method': "topological"
}, {
'subspace': 2,
'value_expression': theta_h,
'degree': 2,
'location_expression': "near(x[0], 1.)",
'method': "topological"
}],
regularization={
'T_f': theta_f,
'r': r
},
nlp_absolute_tolerance=nlp_absolute_tolerance,
end_time=end_time,
time_step_bounds=dt,
output_times=('end', ),
automatic_jacobian=automatic_jacobian)
return w
def test_stefan_problem_solidify__nightly(Ste=0.125,
theta_h=0.01,
theta_c=-1.,
theta_f=0.,
r=0.01,
dt=0.01,
end_time=1.,
nlp_absolute_tolerance=1.e-4,
initial_uniform_cell_count=100,
cool_boundary_refinement_cycles=0):
mesh = fenics.UnitIntervalMesh(initial_uniform_cell_count)
mesh = refine_near_left_boundary(mesh, cool_boundary_refinement_cycles)
w, mesh = phaseflow.run(
output_dir="output/test_stefan_problem_solidify/dt" + str(dt) +
"/tol" + str(nlp_absolute_tolerance) + "/",
prandtl_number=1.,
stefan_number=Ste,
gravity=[0.],
mesh=mesh,
initial_values_expression=("0.", "0.",
"(" + str(theta_c) + " - " + str(theta_h) +
")*near(x[0], 0.) + " + str(theta_h)),
boundary_conditions=[{
'subspace': 0,
'value_expression': [0.],
'degree': 3,
'location_expression': "near(x[0], 0.) | near(x[0], 1.)",
'method': "topological"
}, {
'subspace': 2,
'value_expression': theta_c,
'degree': 2,
'location_expression': "near(x[0], 0.)",
'method': "topological"
}, {
'subspace': 2,
'value_expression': theta_h,
'degree': 2,
'location_expression': "near(x[0], 1.)",
'method': "topological"
}],
temperature_of_fusion=theta_f,
regularization_smoothing_factor=r,
nlp_absolute_tolerance=nlp_absolute_tolerance,
adaptive=True,
adaptive_solver_tolerance=1.e-8,
end_time=end_time,
time_step_size=dt)
""" Verify against solution from MATLAB script solving Worster2000. """
verify_pci_position(true_pci_position=0.49, r=r, w=w)
def stefan_problem(Ste=1.,
theta_h=1.,
theta_c=-1.,
r=0.005,
dt=0.001,
end_time=0.01,
initial_uniform_cell_count=1,
hot_boundary_refinement_cycles=10):
mesh = fenics.UnitIntervalMesh(initial_uniform_cell_count)
mesh = refine_near_left_boundary(mesh, hot_boundary_refinement_cycles)
w, mesh = phaseflow.run(
output_dir="output/test_stefan_problem_Ste" +
str(Ste).replace(".", "p") + "/",
prandtl_number=1.,
stefan_number=Ste,
gravity=[0.],
mesh=mesh,
initial_values_expression=("0.", "0.",
"(" + str(theta_h) + " - " + str(theta_c) +
")*near(x[0], 0.) + " + str(theta_c)),
boundary_conditions=[{
'subspace': 0,
'value_expression': [0.],
'degree': 3,
'location_expression': "near(x[0], 0.) | near(x[0], 1.)",
'method': "topological"
}, {
'subspace': 2,
'value_expression': theta_h,
'degree': 2,
'location_expression': "near(x[0], 0.)",
'method': "topological"
}, {
'subspace': 2,
'value_expression': theta_c,
'degree': 2,
'location_expression': "near(x[0], 1.)",
'method': "topological"
}],
temperature_of_fusion=0.01,
regularization_smoothing_factor=r,
nlp_relative_tolerance=1.e-8,
adaptive=True,
adaptive_solver_tolerance=1.e-8,
end_time=end_time,
time_step_size=dt)
return w
def solve_poisson_eps(h, eps, plot=False):
eps = fe.Constant(eps)
n = int(1 / h)
# Create mesh and define function space
mesh = fe.UnitIntervalMesh(n)
V = fe.FunctionSpace(mesh, 'P', 1)
# Define boundary condition
u_D = fe.Constant(0.0)
# Find exact solution:
u_exact = fe.Expression(
"(1./2 - x[0]) * (2 * x[0] + eps/(2*pi) * sin(2*pi*x[0]/eps)) "
"+ eps*eps/(2*pi*2*pi) * (1 - cos(2*pi*x[0]/eps)) + x[0]*x[0]",
eps=eps,
degree=4)
def boundary(x, on_boundary):
return on_boundary
bc = fe.DirichletBC(V, u_D, boundary)
# Define variational problem
u = fe.TrialFunction(V)
v = fe.TestFunction(V)
f = fe.Constant(1)
A = fe.Expression('1./(2+cos(2*pi*x[0]/eps))', eps=eps, degree=2)
a = A * fe.dot(fe.grad(u), fe.grad(v)) * fe.dx
L = f * v * fe.dx
# Compute solution
u = fe.Function(V)
fe.solve(a == L, u, bc)
if plot:
# Plot solution
fe.plot(u)
fe.plot(u_exact, mesh=mesh)
# Hold plot
fe.interactive()
# # Save solution to file in VTK format
# vtkfile = fe.File('poisson/solution.pvd')
# vtkfile << u
# Compute error
err_norm = fe.errornorm(u_exact, u, 'L2')
return err_norm
def check_solver_options():
"""
Check all the options available for the implemented solver.
Returns
-------
None.
"""
# Create some trivial nonlinear solver instance.
mesh = fn.UnitIntervalMesh(1)
V = fn.FunctionSpace(mesh, "CG", 1)
problem = fn.NonlinearVariationalProblem(
fn.Function(V) * fn.TestFunction(V) * fn.dx, fn.Function(V))
solver = mp.BlockPETScSNESSolver(problem)
# Print out all the options for its parameters:
fn.info(solver.parameters, True)
def test_1d_output_unit__ci__():
sim = phaseflow.phasechange_simulation.PhaseChangeSimulation()
sim.mesh = fenics.UnitIntervalMesh(5)
sim.setup_element()
function_space = fenics.FunctionSpace(sim.mesh, sim.element)
state = phaseflow.state.State(function_space, sim.element)
with phaseflow.helpers.SolutionFile(tempfile.mkdtemp() + "/output/test_1D_output/solution.xdmf") \
as solution_file:
sim.write_solution(solution_file, state)
def __init__(self, h, eps, dim):
"""
Initializing poisson solver
:param h: mesh size (of unit interval discretisation)
:param eps: small parameter
:param dim: dimension (in {1,2,3})
"""
self.h = h
self.n = int(1 / h)
self.eps = eps
self.dim = dim
self.mesh = fe.UnitIntervalMesh(self.n)
a_eps = '1./(2+cos(2*pi*x[0]/eps))'
self.e_is = [fe.Constant(1.)]
if self.dim == 2:
self.mesh = fe.UnitSquareMesh(self.n, self.n)
a_eps = '1./(2+cos(2*pi*(x[0]+2*x[1])/eps))'
self.e_is = [fe.Constant((1., 0.)), fe.Constant((0., 1.))]
elif self.dim == 3:
self.mesh = fe.UnitCubeMesh(self.n, self.n, self.n)
a_eps = '1./(2+cos(2*pi*(x[0]+3*x[1]+6*x[2])/eps))'
self.e_is = [
fe.Constant((1., 0., 0.)),
fe.Constant((0., 1., 0.)),
fe.Constant((0., 0., 1.))
]
else:
self.dim = 1
print("Solving rapid varying Poisson problem in R^%d" % self.dim)
self.diff_coef = fe.Expression(a_eps,
eps=self.eps,
degree=2,
domain=self.mesh)
self.a_y = fe.Expression(a_eps.replace("/eps", ""),
degree=2,
domain=self.mesh)
self.function_space = fe.FunctionSpace(self.mesh, 'P', 2)
self.solution = fe.Function(self.function_space)
self.cell_solutions = [
fe.Function(self.function_space) for _ in range(self.dim)
]
self.eff_diff = np.zeros((self.dim, self.dim))
# Define boundary condition
self.bc_function = fe.Constant(0.0)
self.f = fe.Constant(1)
def test_apply_boundary_conditions():
mesh = fenics.UnitIntervalMesh(10)
V = fenics.FunctionSpace(mesh, 'P', 1)
surface_markers = fenics.MeshFunction(
"size_t", mesh, mesh.topology().dim()-1, 0)
surface_markers.set_all(0)
i = 0
for f in fenics.facets(mesh):
i += 1
x0 = f.midpoint()
surface_markers[f] = 0
if fenics.near(x0.x(), 0):
surface_markers[f] = 1
if fenics.near(x0.x(), 1):
surface_markers[f] = 2
boundary_conditions = [
{
"surface": [1],
"value": 0,
"component": 0,
"type": "dc"
},
{
"surface": [2],
"value": 1,
"type": "dc"
}
]
bcs, expressions = FESTIM.apply_boundary_conditions(
boundary_conditions, V, surface_markers, 1, 300)
assert len(bcs) == 2
assert len(expressions) == 2
u = fenics.Function(V)
for bc in bcs:
bc.apply(u.vector())
assert abs(u(0)-0) < 1e-15
assert abs(u(1)-1) < 1e-15
def test_1d_output():
T_h = 1.
T_c = -1.
w = phaseflow.run(
output_dir = "output/test_1D_output/",
prandtl_number = 1.,
stefan_number = 1.,
gravity = [0.],
mesh = fenics.UnitIntervalMesh(1000),
initial_values_expression = (
"0.",
"0.",
"(" + str(T_h) + " - " + str(T_c) + ")*near(x[0], 0.) " + str(T_c)),
boundary_conditions = [
{"subspace": 0, "value_expression": [0.], "degree": 3, "location_expression": "near(x[0], 0.) | near(x[0], 1.)", "method": "topological"},
{"subspace": 2, "value_expression": T_h, "degree": 2, "location_expression": "near(x[0], 0.)", "method": "topological"},
{"subspace": 2, "value_expression": T_c, "degree": 2, "location_expression": "near(x[0], 1.)", "method": "topological"}],
temperature_of_fusion = 0.01,
regularization_smoothing_factor = 0.005,
end_time = 0.001,
time_step_size = 0.001)
| .. ..
0.55555 |----------..-------------------------------..----------
| ... ...
| .. ..
| .. ..
| .. ..
0 |_______________________________________________________
0 0.5 1
"""
import fenics as fe
import matplotlib.pyplot as plt
if __name__ == "__main__":
n_elements = 32
mesh = fe.UnitIntervalMesh(n_elements)
# Define a Function Space
lagrange_polynomial_space_first_order = fe.FunctionSpace(
mesh, "Lagrange", 1)
# The value of the solution on the boundary
u_on_boundary = fe.Constant(0.0)
# A function to return whether we are on the boundary
def boundary_boolean_function(x, on_boundary):
return on_boundary
# The homogeneous Dirichlet Boundary Condition
boundary_condition = fe.DirichletBC(
lagrange_polynomial_space_first_order,
def setup_coarse_mesh(self):
""" Set the 1D mesh """
self.mesh = fenics.UnitIntervalMesh(self.initial_uniform_cell_count)
def test_formulation_2_traps_1_material():
'''
Test function formulation() with 2 intrinsic traps
and 1 material
'''
# Set parameters
dt = 1
traps = [{
"energy": 1,
"density": 2,
"materials": [1]
},
{
"energy": 1,
"density": 2,
"materials": [1]
}]
materials = [{
"alpha": 1,
"beta": 2,
"density": 3,
"borders": [0, 1],
"E_diff": 4,
"D_0": 5,
"id": 1
}]
extrinsic_traps = []
# Prepare
mesh = fenics.UnitIntervalMesh(10)
V = fenics.VectorFunctionSpace(mesh, 'P', 1, len(traps)+1)
u = fenics.Function(V)
u_n = fenics.Function(V)
v = fenics.TestFunction(V)
solutions = list(fenics.split(u))
previous_solutions = list(fenics.split(u_n))
testfunctions = list(fenics.split(v))
mf = fenics.MeshFunction('size_t', mesh, 1, 1)
dx = fenics.dx(subdomain_data=mf)
temp = fenics.Expression("300", degree=0)
flux_ = fenics.Expression("1", degree=0)
F, expressions = FESTIM.formulation(
traps, extrinsic_traps, solutions, testfunctions,
previous_solutions, dt, dx, materials, temp, flux_)
# Transient sol
expected_form = ((solutions[0] - previous_solutions[0]) / dt) * \
testfunctions[0]*dx
# Diffusion sol
expected_form += 5 * fenics.exp(-4/8.6e-5/temp) * \
fenics.dot(
fenics.grad(solutions[0]), fenics.grad(testfunctions[0]))*dx(1)
# Source sol
expected_form += -flux_*testfunctions[0]*dx
# Transient trap 1
expected_form += ((solutions[1] - previous_solutions[1]) / dt) * \
testfunctions[1]*dx
# Trapping trap 1
expected_form += - 5 * fenics.exp(-4/8.6e-5/temp)/1/1/2 * \
solutions[0] * (2 - solutions[1]) * \
testfunctions[1]*dx(1)
# Detrapping trap 1
expected_form += 1e13*fenics.exp(-1/8.6e-5/temp)*solutions[1] * \
testfunctions[1]*dx(1)
# Source detrapping sol
expected_form += ((solutions[1] - previous_solutions[1]) / dt) * \
testfunctions[0]*dx
# Transient trap 2
expected_form += ((solutions[2] - previous_solutions[2]) / dt) * \
testfunctions[2]*dx
# Trapping trap 2
expected_form += - 5 * fenics.exp(-4/8.6e-5/temp)/1/1/2 * \
solutions[0] * (2 - solutions[2]) * \
testfunctions[2]*dx(1)
# Detrapping trap 2
expected_form += 1e13*fenics.exp(-1/8.6e-5/temp)*solutions[2] * \
testfunctions[2]*dx(1)
# Source detrapping 2 sol
expected_form += ((solutions[2] - previous_solutions[2]) / dt) * \
testfunctions[0]*dx
assert expected_form.equals(F) is True
def test_formulation_1_trap_2_materials():
'''
Test function formulation() with 1 intrinsic trap
and 2 materials
'''
def create_subdomains(x1, x2):
class domain(FESTIM.SubDomain):
def inside(self, x, on_boundary):
return x[0] >= x1 and x[0] <= x2
domain = domain()
return domain
dt = 1
traps = [{
"energy": 1,
"density": 2,
"materials": [1, 2]
}]
materials = [{
"alpha": 1,
"beta": 2,
"density": 3,
"borders": [0, 0.5],
"E_diff": 4,
"D_0": 5,
"id": 1
},
{
"alpha": 2,
"beta": 3,
"density": 4,
"borders": [0.5, 1],
"E_diff": 5,
"D_0": 6,
"id": 2
}]
extrinsic_traps = []
mesh = fenics.UnitIntervalMesh(10)
mf = fenics.MeshFunction("size_t", mesh, 1, 1)
mat1 = create_subdomains(0, 0.5)
mat2 = create_subdomains(0.5, 1)
mat1.mark(mf, 1)
mat2.mark(mf, 2)
V = fenics.VectorFunctionSpace(mesh, 'P', 1, 2)
u = fenics.Function(V)
u_n = fenics.Function(V)
v = fenics.TestFunction(V)
solutions = list(fenics.split(u))
previous_solutions = list(fenics.split(u_n))
testfunctions = list(fenics.split(v))
mf = fenics.MeshFunction('size_t', mesh, 1, 1)
dx = fenics.dx(subdomain_data=mf)
temp = fenics.Expression("300", degree=0)
flux_ = fenics.Expression("1", degree=0)
F, expressions = FESTIM.formulation(
traps, extrinsic_traps, solutions, testfunctions,
previous_solutions, dt, dx, materials, temp, flux_)
# Transient sol
expected_form = ((solutions[0] - previous_solutions[0]) / dt) * \
testfunctions[0]*dx
# Diffusion sol mat 1
expected_form += 5 * fenics.exp(-4/8.6e-5/temp) * \
fenics.dot(
fenics.grad(solutions[0]), fenics.grad(testfunctions[0]))*dx(1)
# Diffusion sol mat 2
expected_form += 6 * fenics.exp(-5/8.6e-5/temp) * \
fenics.dot(
fenics.grad(solutions[0]), fenics.grad(testfunctions[0]))*dx(2)
# Source sol
expected_form += -flux_*testfunctions[0]*dx
# Transient trap 1
expected_form += ((solutions[1] - previous_solutions[1]) / dt) * \
testfunctions[1]*dx
# Trapping trap 1 mat 1
expected_form += - 5 * fenics.exp(-4/8.6e-5/temp)/1/1/2 * \
solutions[0] * (2 - solutions[1]) * \
testfunctions[1]*dx(1)
# Trapping trap 1 mat 2
expected_form += - 6 * fenics.exp(-5/8.6e-5/temp)/2/2/3 * \
solutions[0] * (2 - solutions[1]) * \
testfunctions[1]*dx(2)
# Detrapping trap 1 mat 1
expected_form += 1e13*fenics.exp(-1/8.6e-5/temp)*solutions[1] * \
testfunctions[1]*dx(1)
# Detrapping trap 1 mat 2
expected_form += 1e13*fenics.exp(-1/8.6e-5/temp)*solutions[1] * \
testfunctions[1]*dx(2)
# Source detrapping sol
expected_form += ((solutions[1] - previous_solutions[1]) / dt) * \
testfunctions[0]*dx
assert expected_form.equals(F) is True
# * Prandl number is taken to be one.
#
#
# Writing it in weak form, here v is the test function
#
# (𝑣,𝜕𝑡ℎ)=−𝑑𝑇/𝑑ℎ(𝑘/𝜌)(∇𝑣,∇ℎ)
#
# Since it is a non-linear problem,
#
# F= (𝑣,𝜕𝑡ℎ)+𝑑𝑇/𝑑ℎ (𝑘/𝜌)(∇𝑣,∇ℎ)=0
#
# is solved by newton's method.
#
#The one dimensional mesg spanned by piecewise polynomial
mesh = fe.UnitIntervalMesh(Mesh_size) #One Dimensional mesh
P1 = fe.FiniteElement('P', mesh.ufl_cell(), 1)
V = fe.FunctionSpace(
mesh, P1) #Function space spanned by piecewise linear polynomials
v = fe.TestFunction(V) #Test function
h = fe.Function(V) #Enthalpy-Trial function
fe.plot(mesh)
plt.show()
#Temperature is assumed to be a function of the third power of enthalpy as a guess.
def Temp(h): #Temperature as a function of enthalpy
return (
(h)**3
) # Approximating the fuction to be cubic such that it closely resemble the physics of the problem
def coarse_mesh(self):
self.initial_uniform_cell_count = 4
return fenics.UnitIntervalMesh(self.initial_uniform_cell_count)
import numpy as onp
import fenics as fn
import ufl
from jaxfenics import build_jax_solve_eval, build_jax_assemble_eval
from jaxfenics import numpy_to_fenics, fenics_to_numpy
import matplotlib.pyplot as plt
config.update("jax_enable_x64", True)
fn.set_log_level(fn.LogLevel.ERROR)
# Create mesh
n = 30
mesh = fn.UnitIntervalMesh(n)
# Define discrete function spaces and functions
V = fn.FunctionSpace(mesh, "CG", 2)
v = fn.TestFunction(V)
nu = fn.Constant(0.0001)
a = fn.Constant(0.4)
timestep = np.asarray([0.05])
bcs = [fn.DirichletBC(V, 0.0, "on_boundary")]
def Dt(u, u_prev, timestep):
return (u - u_prev) / timestep
import fenics
N = 1000
mesh = fenics.UnitIntervalMesh(N)
P1 = fenics.FiniteElement('P', mesh.ufl_cell(), 1)
V = fenics.FunctionSpace(mesh, P1)
psi = fenics.TestFunction(V)
T = fenics.Function(V)
stefan_number = 0.045
Ste = fenics.Constant(stefan_number)
regularization_central_temperature = 0.
T_r = fenics.Constant(regularization_central_temperature)
regularization_smoothing_parameter = 0.005
r = fenics.Constant(regularization_smoothing_parameter)
