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)