diff --git a/LDDsimulation/LDDsimulation.py b/LDDsimulation/LDDsimulation.py
index 6208b6c48545e2fc3aca0e120c52925bfda3662f..d46d817cbd170b1009bbd33535fbce355e4f2cae 100644
--- a/LDDsimulation/LDDsimulation.py
+++ b/LDDsimulation/LDDsimulation.py
@@ -54,9 +54,9 @@ class LDDsimulation(object):
#Parameters
# df.parameters["allow_extrapolation"] = True
# df.parameters["refinement_algorithm"] = "plaza_with_parent_facets"
- df.parameters["form_compiler"]["quadrature_degree"] = 12
+ df.parameters["form_compiler"]["quadrature_degree"] = 14
# interpolation degree, for source terms, intitial and boundary conditions.
- self.interpolation_degree = 4
+ self.interpolation_degree = 6
# # To be able to run DG in parallel
# df.parameters["ghost_mode"] = "shared_facet"
# df.parameters["ghost_mode"] = "none"
@@ -720,7 +720,7 @@ class LDDsimulation(object):
for phase in subdomain.has_phases:
pa_exact = subdomain.pressure_exact[phase]
pa_exact.t = self.t
- error_calculated = df.errornorm(pa_exact, subdomain.pressure[phase], 'L2', degree_rise=2)
+ error_calculated = df.errornorm(pa_exact, subdomain.pressure[phase], 'L2', degree_rise=4)
pressure_exact.update(
{phase: df.interpolate(pa_exact, subdomain.function_space["pressure"][phase])}
)
@@ -728,22 +728,22 @@ class LDDsimulation(object):
pressure_difference = pressure_exact[phase].vector()[:] - subdomain.pressure[phase].vector()[:]
abs_diff_tmp = np.fabs(pressure_difference)
absolute_difference.vector()[:] = abs_diff_tmp
- dx = subdomain.dx
- error_calculated_L1 = df.assemble(absolute_difference*dx)
- error_calculated_L2 = np.sqrt(df.assemble(absolute_difference**2*dx))
- error_calculated_L2_2 = df.norm(absolute_difference, norm_type='L2', mesh=subdomain.mesh)
- print(f"Errornorm dolfin: {error_calculated}")
- print(f"Errornorm manually calculated L1: {error_calculated_L1}")
- print(f"Errornorm manually calculated L2: {error_calculated_L2}")
- print(f"Errornorm manually calculated L2 with df.norm: {error_calculated_L2_2}")
+ # dx = subdomain.dx
+ # error_calculated_L1 = df.assemble(absolute_difference*dx)
+ # error_calculated_L2 = np.sqrt(df.assemble(absolute_difference**2*dx))
+ # error_calculated_L2_2 = df.norm(absolute_difference, norm_type='L2', mesh=subdomain.mesh)
+ # print(f"Errornorm dolfin: {error_calculated}")
+ # print(f"Errornorm manually calculated L1: {error_calculated_L1}")
+ # print(f"Errornorm manually calculated L2: {error_calculated_L2}")
+ # print(f"Errornorm manually calculated L2 with df.norm: {error_calculated_L2_2}")
self.output[subdom_ind]['errornorm'][phase]['L1'] += self.timestep_size*error_calculated
self.output[subdom_ind]['errornorm'][phase]['L2'] += self.timestep_size*error_calculated**2
- print(f"Linf error on subdomain {subdom_ind} and phase {phase} before checking: {self.output[subdom_ind]['errornorm'][phase]['Linf']}")
+ # print(f"Linf error on subdomain {subdom_ind} and phase {phase} before checking: {self.output[subdom_ind]['errornorm'][phase]['Linf']}")
if error_calculated > self.output[subdom_ind]['errornorm'][phase]['Linf']:
self.output[subdom_ind]['errornorm'][phase].update(
{'Linf': error_calculated}
)
- print(f"Linf error on subdomain {subdom_ind} and phase {phase} after checking: {self.output[subdom_ind]['errornorm'][phase]['Linf']}")
+ # print(f"Linf error on subdomain {subdom_ind} and phase {phase} after checking: {self.output[subdom_ind]['errornorm'][phase]['Linf']}")
# if we are at a timestep at which to write shit out,
# calculate the relative errornorm
diff --git a/TP-R-two-patch-test-case/mesh_studies/TP-R-2-patch-mesh-study.py b/TP-R-two-patch-test-case/mesh_studies/TP-R-2-patch-mesh-study.py
new file mode 100755
index 0000000000000000000000000000000000000000..8cd8021c552aa677b2abda941238e299ae0bf026
--- /dev/null
+++ b/TP-R-two-patch-test-case/mesh_studies/TP-R-2-patch-mesh-study.py
@@ -0,0 +1,511 @@
+#!/usr/bin/python3
+import dolfin as df
+import mshr
+import numpy as np
+import sympy as sym
+import typing as tp
+import domainPatch as dp
+import LDDsimulation as ldd
+import functools as ft
+import helpers as hlp
+import datetime
+import os
+import pandas as pd
+
+date = datetime.datetime.now()
+datestr = date.strftime("%Y-%m-%d")
+#import ufl as ufl
+
+# init sympy session
+sym.init_printing()
+
+use_case = "TP-R-2-patch-realistic"
+# solver_tol = 6E-7
+max_iter_num = 1000
+FEM_Lagrange_degree = 1
+mesh_study = True
+resolutions = { 1: 5e-7,
+ 2: 5e-7,
+ 4: 5e-7,
+ 8: 5e-7,
+ 16: 5e-7,
+ 32: 5e-7,
+ 64: 5e-7,
+ 128: 5e-7,
+ 256: 5e-7}
+
+############ GRID #######################
+# mesh_resolution = 20
+timestep_size = 0.001
+number_of_timesteps = 600
+plot_timestep_every = 2
+# decide how many timesteps you want analysed. Analysed means, that we write out
+# subsequent errors of the L-iteration within the timestep.
+number_of_timesteps_to_analyse = 4
+starttime = [0.0, 0.5]
+
+Lw = 0.025 #/timestep_size
+Lnw=Lw
+
+lambda_w = 40
+lambda_nw = 40
+
+include_gravity = False
+debugflag = False
+analyse_condition = False
+
+output_string = "./output/{}-{}_timesteps{}_P{}".format(datestr, use_case, number_of_timesteps, FEM_Lagrange_degree)
+
+# toggle what should be written to files
+if mesh_study:
+ write_to_file = {
+ 'space_errornorms': True,
+ 'meshes_and_markers': True,
+ 'L_iterations_per_timestep': False,
+ 'solutions': False,
+ 'absolute_differences': False,
+ 'condition_numbers': analyse_condition,
+ 'subsequent_errors': False
+ }
+else:
+ write_to_file = {
+ 'space_errornorms': True,
+ 'meshes_and_markers': True,
+ 'L_iterations_per_timestep': False,
+ 'solutions': True,
+ 'absolute_differences': True,
+ 'condition_numbers': analyse_condition,
+ 'subsequent_errors': True
+ }
+
+
+
+##### Domain and Interface ####
+# global simulation domain domain
+sub_domain0_vertices = [df.Point(-1.0, -1.0),
+ df.Point(1.0, -1.0),
+ df.Point(1.0, 1.0),
+ df.Point(-1.0, 1.0)]
+# interface between subdomain1 and subdomain2
+interface12_vertices = [df.Point(-1.0, 0.0),
+ df.Point(1.0, 0.0) ]
+# subdomain1.
+sub_domain1_vertices = [interface12_vertices[0],
+ interface12_vertices[1],
+ sub_domain0_vertices[2],
+ sub_domain0_vertices[3]]
+
+# vertex coordinates of the outer boundaries. If it can not be specified as a
+# polygon, use an entry per boundary polygon. This information is used for defining
+# the Dirichlet boundary conditions. If a domain is completely internal, the
+# dictionary entry should be 0: None
+subdomain1_outer_boundary_verts = {
+ 0: [interface12_vertices[1], #
+ sub_domain0_vertices[2],
+ sub_domain0_vertices[3], #
+ interface12_vertices[0]]
+}
+# subdomain2
+sub_domain2_vertices = [sub_domain0_vertices[0],
+ sub_domain0_vertices[1],
+ interface12_vertices[1],
+ interface12_vertices[0] ]
+
+subdomain2_outer_boundary_verts = {
+ 0: [interface12_vertices[0], #
+ sub_domain0_vertices[0],
+ sub_domain0_vertices[1],
+ interface12_vertices[1]]
+}
+
+# list of subdomains given by the boundary polygon vertices.
+# Subdomains are given as a list of dolfin points forming
+# a closed polygon, such that mshr.Polygon(subdomain_def_points[i]) can be used
+# to create the subdomain. subdomain_def_points[0] contains the
+# vertices of the global simulation domain and subdomain_def_points[i] contains the
+# vertices of the subdomain i.
+subdomain_def_points = [sub_domain0_vertices,#
+ sub_domain1_vertices,#
+ sub_domain2_vertices]
+# in the below list, index 0 corresponds to the 12 interface which has index 1
+interface_def_points = [interface12_vertices]
+
+# if a subdomain has no outer boundary write None instead, i.e.
+# i: None
+# if i is the index of the inner subdomain.
+outer_boundary_def_points = {
+ # subdomain number
+ 1 : subdomain1_outer_boundary_verts,
+ 2 : subdomain2_outer_boundary_verts
+}
+
+# adjacent_subdomains[i] contains the indices of the subdomains sharing the
+# interface i (i.e. given by interface_def_points[i]).
+adjacent_subdomains = [[1,2]]
+isRichards = {
+ 1: True, #
+ 2: False
+ }
+
+
+viscosity = {#
+# subdom_num : viscosity
+ 1 : {'wetting' :1},
+ #'nonwetting': 1}, #
+ 2 : {'wetting' :1,
+ 'nonwetting': 1/50}
+}
+
+porosity = {#
+# subdom_num : porosity
+ 1 : 0.22,#
+ 2 : 0.0022
+}
+
+# Dict of the form: { subdom_num : density }
+densities = {
+ 1: {'wetting': 997},
+ 2: {'wetting': 997,
+ 'nonwetting': 1.225},
+}
+
+gravity_acceleration = 9.81
+
+L = {#
+# subdom_num : subdomain L for L-scheme
+ 1 : {'wetting' :Lw},
+ # 'nonwetting': 0.25},#
+ 2 : {'wetting' :Lw,
+ 'nonwetting': Lnw}
+}
+
+
+lambda_param = {#
+# subdom_num : lambda parameter for the L-scheme
+ 1 : {'wetting' :l_param_w},
+ # 'nonwetting': l_param},#
+ 2 : {'wetting' :l_param_w,
+ 'nonwetting': l_param_nw}
+}
+
+## relative permeabilty functions on subdomain 1
+def rel_perm1w(s):
+ # relative permeabilty wetting on subdomain1
+ return s**2
+
+# def rel_perm1nw(s):
+# # relative permeabilty nonwetting on subdomain1
+# return (1-s)**2
+
+_rel_perm1w = ft.partial(rel_perm1w)
+# _rel_perm1nw = ft.partial(rel_perm1nw)
+subdomain1_rel_perm = {
+ 'wetting': _rel_perm1w,#
+ # 'nonwetting': _rel_perm1nw
+}
+## relative permeabilty functions on subdomain 2
+def rel_perm2w(s):
+ # relative permeabilty wetting on subdomain2
+ return s**3
+def rel_perm2nw(s):
+ # relative permeabilty nonwetting on subdosym.cos(0.8*t - (0.8*x + 1/7*y))main2
+ return (1-s)**3
+
+_rel_perm2w = ft.partial(rel_perm2w)
+_rel_perm2nw = ft.partial(rel_perm2nw)
+
+subdomain2_rel_perm = {
+ 'wetting': _rel_perm2w,#
+ 'nonwetting': _rel_perm2nw
+}
+
+## dictionary of relative permeabilties on all domains.
+relative_permeability = {#
+ 1: subdomain1_rel_perm,
+ 2: subdomain2_rel_perm
+}
+
+
+# definition of the derivatives of the relative permeabilities
+# relative permeabilty functions on subdomain 1
+def rel_perm1w_prime(s):
+ # relative permeabilty on subdomain1
+ return 2*s
+
+# def rel_perm1nw_prime(s):
+# # relative permeabilty on subdomain1
+# return 2*(1-s)
+
+# definition of the derivatives of the relative permeabilities
+# relative permeabilty functions on subdomain 1
+def rel_perm2w_prime(s):
+ # relative permeabilty on subdomain1
+ return 3*s**2
+
+def rel_perm2nw_prime(s):
+ # relative permeabilty on subdomain1
+ return -3*(1-s)**2
+
+_rel_perm1w_prime = ft.partial(rel_perm1w_prime)
+# _rel_perm1nw_prime = ft.partial(rel_perm1nw_prime)
+_rel_perm2w_prime = ft.partial(rel_perm2w_prime)
+_rel_perm2nw_prime = ft.partial(rel_perm2nw_prime)
+
+subdomain1_rel_perm_prime = {
+ 'wetting': _rel_perm1w_prime
+ # 'nonwetting': _rel_perm1nw_prime
+}
+
+
+subdomain2_rel_perm_prime = {
+ 'wetting': _rel_perm2w_prime,
+ 'nonwetting': _rel_perm2nw_prime
+}
+
+# dictionary of relative permeabilties on all domains.
+ka_prime = {
+ 1: subdomain1_rel_perm_prime,
+ 2: subdomain2_rel_perm_prime,
+}
+
+
+# def saturation1(pc, subdomain_index):
+# # inverse capillary pressure-saturation-relationship
+# return df.conditional(pc > 0, 1/((1 + pc)**(1/(subdomain_index + 1))), 1)
+#
+# def saturation2(pc, n_index, alpha):
+# # inverse capillary pressure-saturation-relationship
+# return df.conditional(pc > 0, 1/((1 + (alpha*pc)**n_index)**((n_index - 1)/n_index)), 1)
+#
+# # S-pc-relation ship. We use the van Genuchten approach, i.e. pc = 1/alpha*(S^{-1/m} -1)^1/n, where
+# # we set alpha = 0, assume m = 1-1/n (see Helmig) and assume that residual saturation is Sw
+# def saturation1_sym(pc, subdomain_index):
+# # inverse capillary pressure-saturation-relationship
+# return 1/((1 + pc)**(1/(subdomain_index + 1)))
+#
+#
+# def saturation2_sym(pc, n_index, alpha):
+# # inverse capillary pressure-saturation-relationship
+# #df.conditional(pc > 0,
+# return 1/((1 + (alpha*pc)**n_index)**((n_index - 1)/n_index))
+#
+#
+# # derivative of S-pc relationship with respect to pc. This is needed for the
+# # construction of a analytic solution.
+# def saturation1_sym_prime(pc, subdomain_index):
+# # inverse capillary pressure-saturation-relationship
+# return -(1/(subdomain_index + 1))*(1 + pc)**((-subdomain_index - 2)/(subdomain_index + 1))
+#
+#
+# def saturation2_sym_prime(pc, n_index, alpha):
+# # inverse capillary pressure-saturation-relationship
+# return -(alpha*(n_index - 1)*(alpha*pc)**(n_index - 1)) / ( (1 + (alpha*pc)**n_index)**((2*n_index - 1)/n_index) )
+#
+# # note that the conditional definition of S-pc in the nonsymbolic part will be
+# # incorporated in the construction of the exact solution below.
+# S_pc_sym = {
+# 1: ft.partial(saturation1_sym, subdomain_index = 1),
+# 2: ft.partial(saturation2_sym, n_index=3, alpha=0.001),
+# }
+#
+# S_pc_sym_prime = {
+# 1: ft.partial(saturation1_sym_prime, subdomain_index = 1),
+# 2: ft.partial(saturation2_sym_prime, n_index=3, alpha=0.001),
+# }
+#
+# sat_pressure_relationship = {
+# 1: ft.partial(saturation1, subdomain_index = 1),#,
+# 2: ft.partial(saturation2, n_index=3, alpha=0.001),
+# }
+
+def saturation(pc, index):
+ # inverse capillary pressure-saturation-relationship
+ return df.conditional(pc > 0, 1/((1 + pc)**(1/(index + 1))), 1)
+
+
+def saturation_sym(pc, index):
+ # inverse capillary pressure-saturation-relationship
+ return 1/((1 + pc)**(1/(index + 1)))
+
+
+# derivative of S-pc relationship with respect to pc. This is needed for the
+# construction of a analytic solution.
+def saturation_sym_prime(pc, index):
+ # inverse capillary pressure-saturation-relationship
+ return -1/((index+1)*(1 + pc)**((index+2)/(index+1)))
+
+
+# note that the conditional definition of S-pc in the nonsymbolic part will be
+# incorporated in the construction of the exact solution below.
+S_pc_sym = {
+ 1: ft.partial(saturation_sym, index=1),
+ 2: ft.partial(saturation_sym, index=2),
+ # 3: ft.partial(saturation_sym, index=2),
+ # 4: ft.partial(saturation_sym, index=1)
+}
+
+S_pc_sym_prime = {
+ 1: ft.partial(saturation_sym_prime, index=1),
+ 2: ft.partial(saturation_sym_prime, index=2),
+ # 3: ft.partial(saturation_sym_prime, index=2),
+ # 4: ft.partial(saturation_sym_prime, index=1)
+}
+
+sat_pressure_relationship = {
+ 1: ft.partial(saturation, index=1),
+ 2: ft.partial(saturation, index=2),
+ # 3: ft.partial(saturation, index=2),
+ # 4: ft.partial(saturation, index=1)
+}
+
+
+#############################################
+# Manufacture source expressions with sympy #
+#############################################
+x, y = sym.symbols('x[0], x[1]') # needed by UFL
+t = sym.symbols('t', positive=True)
+
+p_e_sym = {
+ 1: {'wetting': (-5.0 - (1.0 + t*t)*(1.0 + x*x + y*y))}, #*(1-x)**2*(1+x)**2*(1-y)**2},
+ 2: {'wetting': (-5.0 - (1.0 + t*t)*(1.0 + x*x)), #*(1-x)**2*(1+x)**2*(1+y)**2,
+ 'nonwetting': (-1-t*(1.1+y + x**2))*y**3}, #*(1-x)**2*(1+x)**2*(1+y)**2},
+} #-y*y*(sym.sin(-2*t+2*x)*sym.sin(1/2*y-1.2*t)) - t*t*x*(0.5-y)*y*(1-x)
+
+
+pc_e_sym = dict()
+for subdomain, isR in isRichards.items():
+ if isR:
+ pc_e_sym.update({subdomain: -p_e_sym[subdomain]['wetting'].copy()})
+ else:
+ pc_e_sym.update({subdomain: p_e_sym[subdomain]['nonwetting'].copy()
+ - p_e_sym[subdomain]['wetting'].copy()})
+
+
+symbols = {"x": x,
+ "y": y,
+ "t": t}
+# turn above symbolic code into exact solution for dolphin and
+# construct the rhs that matches the above exact solution.
+exact_solution_example = hlp.generate_exact_solution_expressions(
+ symbols=symbols,
+ isRichards=isRichards,
+ symbolic_pressure=p_e_sym,
+ symbolic_capillary_pressure=pc_e_sym,
+ saturation_pressure_relationship=S_pc_sym,
+ saturation_pressure_relationship_prime=S_pc_sym_prime,
+ viscosity=viscosity,
+ porosity=porosity,
+ relative_permeability=relative_permeability,
+ relative_permeability_prime=ka_prime,
+ densities=densities,
+ gravity_acceleration=gravity_acceleration,
+ include_gravity=include_gravity,
+ )
+source_expression = exact_solution_example['source']
+exact_solution = exact_solution_example['exact_solution']
+initial_condition = exact_solution_example['initial_condition']
+
+# Dictionary of dirichlet boundary conditions.
+dirichletBC = dict()
+# similarly to the outer boundary dictionary, if a patch has no outer boundary
+# None should be written instead of an expression.
+# This is a bit of a brainfuck:
+# dirichletBC[ind] gives a dictionary of the outer boundaries of subdomain ind.
+# Since a domain patch can have several disjoint outer boundary parts, the
+# expressions need to get an enumaration index which starts at 0.
+# So dirichletBC[ind][j] is the dictionary of outer dirichlet conditions of
+# subdomain ind and boundary part j.
+# Finally, dirichletBC[ind][j]['wetting'] and dirichletBC[ind][j]['nonwetting']
+# return the actual expression needed for the dirichlet condition for both
+# phases if present.
+
+# subdomain index: {outer boudary part index: {phase: expression}}
+for subdomain in isRichards.keys():
+ # if subdomain has no outer boundary, outer_boundary_def_points[subdomain] is None
+ if outer_boundary_def_points[subdomain] is None:
+ dirichletBC.update({subdomain: None})
+ else:
+ dirichletBC.update({subdomain: dict()})
+ # set the dirichlet conditions to be the same code as exact solution on
+ # the subdomain.
+ for outer_boundary_ind in outer_boundary_def_points[subdomain].keys():
+ dirichletBC[subdomain].update(
+ {outer_boundary_ind: exact_solution[subdomain]}
+ )
+
+
+# def saturation(pressure, subdomain_index):
+# # inverse capillary pressure-saturation-relationship
+# return df.conditional(pressure < 0, 1/((1 - pressure)**(1/(subdomain_index + 1))), 1)
+#
+# sa
+
+for starttime in starttimes:
+ for mesh_resolution, solver_tol in resolutions.items():
+ # initialise LDD simulation class
+ simulation = ldd.LDDsimulation(
+ tol=1E-14,
+ LDDsolver_tol=solver_tol,
+ debug=debugflag,
+ max_iter_num=max_iter_num,
+ FEM_Lagrange_degree=FEM_Lagrange_degree,
+ mesh_study=mesh_study
+ )
+
+ simulation.set_parameters(use_case=use_case,
+ output_dir=output_string,
+ subdomain_def_points=subdomain_def_points,
+ isRichards=isRichards,
+ interface_def_points=interface_def_points,
+ outer_boundary_def_points=outer_boundary_def_points,
+ adjacent_subdomains=adjacent_subdomains,
+ mesh_resolution=mesh_resolution,
+ viscosity=viscosity,
+ porosity=porosity,
+ L=L,
+ lambda_param=lambda_param,
+ relative_permeability=relative_permeability,
+ saturation=sat_pressure_relationship,
+ starttime=starttime,
+ number_of_timesteps=number_of_timesteps,
+ number_of_timesteps_to_analyse=number_of_timesteps_to_analyse,
+ plot_timestep_every=plot_timestep_every,
+ timestep_size=timestep_size,
+ sources=source_expression,
+ initial_conditions=initial_condition,
+ dirichletBC_expression_strings=dirichletBC,
+ exact_solution=exact_solution,
+ densities=densities,
+ include_gravity=include_gravity,
+ write2file=write_to_file,
+ )
+
+ simulation.initialise()
+ output_dir = simulation.output_dir
+ # simulation.write_exact_solution_to_xdmf()
+ output = simulation.run(analyse_condition=analyse_condition)
+ for subdomain_index, subdomain_output in output.items():
+ mesh_h = subdomain_output['mesh_size']
+ for phase, different_errornorms in subdomain_output['errornorm'].items():
+ filename = output_dir + "subdomain{}-space-time-errornorm-{}-phase.csv".format(subdomain_index, phase)
+ # for errortype, errornorm in different_errornorms.items():
+
+ # eocfile = open("eoc_filename", "a")
+ # eocfile.write( str(mesh_h) + " " + str(errornorm) + "\n" )
+ # eocfile.close()
+ # if subdomain.isRichards:mesh_h
+ data_dict = {
+ 'mesh_parameter': mesh_resolution,
+ 'mesh_h': mesh_h,
+ }
+ for error_type, errornorms in different_errornorms.items():
+ data_dict.update(
+ {error_type: errornorms}
+ )
+ errors = pd.DataFrame(data_dict, index=[mesh_resolution])
+ # check if file exists
+ if os.path.isfile(filename) == True:
+ with open(filename, 'a') as f:
+ errors.to_csv(f, header=False, sep='\t', encoding='utf-8', index=False)
+ else:
+ errors.to_csv(filename, sep='\t', encoding='utf-8', index=False)
diff --git a/TP-TP-2-patch-pure-dd-avoid-interface-at-origin/mesh_study_convergence/TP-TP-2-patch-pure-dd-convergence-study.py b/TP-TP-2-patch-pure-dd-avoid-interface-at-origin/mesh_study_convergence/TP-TP-2-patch-pure-dd-convergence-study.py
index 17b8f55aaf8709b89a4d8181efe3087f0af02eaf..e27866da976cf8986115d374623baa77f536ad33 100755
--- a/TP-TP-2-patch-pure-dd-avoid-interface-at-origin/mesh_study_convergence/TP-TP-2-patch-pure-dd-convergence-study.py
+++ b/TP-TP-2-patch-pure-dd-avoid-interface-at-origin/mesh_study_convergence/TP-TP-2-patch-pure-dd-convergence-study.py
@@ -31,19 +31,20 @@ resolutions = { 1: 1e-7,
16: 5e-7,
32: 5e-7,
64: 5e-7,
- 128: 5e-7}
+ 128: 5e-7,
+ 256: 5e-7}
############ GRID #######################
# mesh_resolution = 20
-timestep_size = 0.000025
-number_of_timesteps = 4000
-plot_timestep_every = 40
+timestep_size = 0.001
+number_of_timesteps = 600
+plot_timestep_every = 2
# decide how many timesteps you want analysed. Analysed means, that we write out
# subsequent errors of the L-iteration within the timestep.
-number_of_timesteps_to_analyse = 0
+number_of_timesteps_to_analyse = 4
starttime = 0.0
-Lw = 0.25 #/timestep_size
+Lw = 0.025 #/timestep_size
Lnw=Lw
lambda_w = 40
diff --git a/TP-one-patch/debug_tests/R-one-patch-const-in-time.py b/TP-one-patch/debug_tests/R-one-patch-const-in-time.py
index 6a4865ba0d7ffeb16b900e2b101d1f1868263db2..fb619ab2b354234d0768bbfbbf9fdaefdcc68bdf 100755
--- a/TP-one-patch/debug_tests/R-one-patch-const-in-time.py
+++ b/TP-one-patch/debug_tests/R-one-patch-const-in-time.py
@@ -451,12 +451,6 @@ for subdomain in isRichards.keys():
)
-# def saturation(pressure, subdomain_index):
-# # inverse capillary pressure-saturation-relationship
-# return df.conditional(pressure < 0, 1/((1 - pressure)**(1/(subdomain_index + 1))), 1)
-#
-# sa
-
for starttime in starttimes:
for mesh_resolution, solver_tol in resolutions.items():
# initialise LDD simulation class
diff --git a/TP-one-patch/mesh_study/TP-one-patch-mesh-study.py b/TP-one-patch/mesh_study/TP-one-patch-mesh-study.py
index fe6451ecb4134527694c56a5e994339d2c8d3405..bed62b609b08a817ee764588d230195c31e6a9d2 100755
--- a/TP-one-patch/mesh_study/TP-one-patch-mesh-study.py
+++ b/TP-one-patch/mesh_study/TP-one-patch-mesh-study.py
@@ -26,25 +26,26 @@ FEM_Lagrange_degree = 1
mesh_study = True
# resolutions = {128: 1e-7} #[1,2,3,4,5,10,20,40,75,100]
resolutions = { 1: 1e-7,
- 2: 2e-5,
- 4: 1e-6,
- 8: 1e-6,
- 16: 6e-7,
- 32: 6e-7,
- 64: 6e-7,
- 128: 6e-7}
+ 2: 1e-7,
+ 4: 1e-7,
+ 8: 1e-7,
+ 16: 1e-7,
+ 32: 1e-7,
+ 64: 1e-7,
+ 128: 1e-7,
+ 256: 1e-7}
############ GRID #######################
# mesh_resolution = 20
-timestep_size = 0.000025
-number_of_timesteps = 4000
-plot_timestep_every = 40
+timestep_size = 0.01
+number_of_timesteps = 80
+plot_timestep_every = 1
# decide how many timesteps you want analysed. Analysed means, that we write out
# subsequent errors of the L-iteration within the timestep.
-number_of_timesteps_to_analyse = 0
+number_of_timesteps_to_analyse = 4
starttime = 0.0
-Lw = 0.25 #/timestep_size
+Lw = 0.025 #/timestep_size
Lnw=Lw
lambda_w = 40