diff --git a/Two-phase-Richards/multi-patch/five_patch_domain_with_inner_patch/TP-R-multi-patch-with-inner-patch.py b/Two-phase-Richards/multi-patch/five_patch_domain_with_inner_patch/TP-R-multi-patch-with-inner-patch.py
new file mode 100755
index 0000000000000000000000000000000000000000..15f9e9dc9ed1fc26445d2029178bd42eedcb41a1
--- /dev/null
+++ b/Two-phase-Richards/multi-patch/five_patch_domain_with_inner_patch/TP-R-multi-patch-with-inner-patch.py
@@ -0,0 +1,810 @@
+#!/usr/bin/python3
+"""Multi-patch simulation with inner patch.
+
+This program sets up an LDD simulation
+"""
+
+import dolfin as df
+import sympy as sym
+import functools as ft
+import LDDsimulation as ldd
+import helpers as hlp
+import datetime
+import os
+import pandas as pd
+
+# check if output directory exists
+if not os.path.exists('./output'):
+ os.mkdir('./output')
+ print("Directory ", './output', " created ")
+else:
+ print("Directory ", './output', " already exists. Will use as output \
+ directory")
+
+date = datetime.datetime.now()
+datestr = date.strftime("%Y-%m-%d")
+
+
+# init sympy session
+sym.init_printing()
+# solver_tol = 6E-7
+use_case = "TP-R-five-domain-with-inner-patch-realistic"
+# name of this very file. Needed for log output.
+thisfile = "TP-R-multi-patch-with-inner-patch.py"
+max_iter_num = 700
+FEM_Lagrange_degree = 1
+mesh_study = False
+resolutions = {
+ # 1: 2e-6, # h=2
+ # 2: 2e-6, # h=1.1180
+ # 4: 2e-6, # h=0.5590
+ # 8: 2e-6, # h=0.2814
+ # 16: 8e-6, # h=0.1412
+ 32: 5e-6,
+ # 64: 2e-6,
+ # 128: 2e-6
+ }
+
+# GRID #######################
+# mesh_resolution = 20
+timestep_size = 0.001
+number_of_timesteps = 1000
+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 = 8
+starttimes = [0.0]
+
+Lw1 = 0.5 # /timestep_size
+Lnw1 = Lw1
+
+Lw2 = 0.5 # /timestep_size
+Lnw2 = Lw2
+
+Lw3 = 0.5 # /timestep_size
+Lnw3 = Lw3
+
+Lw4 = 0.5 # /timestep_size
+Lnw4 = Lw4
+
+Lw5 = 0.5 # /timestep_size
+Lnw5 = Lw5
+
+
+lambda13_w= 4
+lambda13_nw= 4
+
+lambda12_w = 4
+lambda12_nw = 4
+
+lambda23_w = 4
+lambda23_nw = 4
+
+lambda24_w = 4
+lambda24_nw= 4
+
+lambda34_w = 4
+lambda34_nw = 4
+
+lambda45_w = 4
+lambda45_nw = 4
+
+lambda15_w = 4
+lambda15_nw = 4
+
+
+include_gravity = True
+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': True,
+ 'absolute_differences': True,
+ 'condition_numbers': analyse_condition,
+ 'subsequent_errors': True
+ }
+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)]
+
+# interfaces
+
+interface23_vertices = [df.Point(0.0, -0.6),
+ df.Point(0.7, 0.0)]
+
+interface12_vertices = [interface23_vertices[1],
+ df.Point(1.0, 0.0)]
+
+interface13_vertices = [df.Point(0.0, 0.0),
+ interface23_vertices[1]]
+
+interface15_vertices = [df.Point(0.0, 0.0),
+ df.Point(0.0, 1.0)]
+
+interface34_vertices = [df.Point(0.0, 0.0),
+ interface23_vertices[0]]
+
+interface24_vertices = [interface23_vertices[0],
+ df.Point(0.0, -1.0)]
+
+interface45_vertices = [df.Point(-1.0, 0.0),
+ df.Point(0.0, 0.0)]
+# subdomain1.
+sub_domain1_vertices = [interface23_vertices[0],
+ interface23_vertices[1],
+ interface12_vertices[1],
+ sub_domain0_vertices[2],
+ df.Point(0.0, 1.0)]
+
+# 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 inter-
+# nal, the dictionary entry should be 0: None
+subdomain1_outer_boundary_verts = {
+ 0: [interface12_vertices[1],
+ sub_domain0_vertices[2],
+ df.Point(0.0, 1.0)]
+}
+# subdomain2
+sub_domain2_vertices = [interface24_vertices[1],
+ sub_domain0_vertices[1],
+ interface12_vertices[1],
+ interface23_vertices[1],
+ interface23_vertices[0]]
+
+subdomain2_outer_boundary_verts = {
+ 0: [interface24_vertices[1],
+ sub_domain0_vertices[1],
+ interface12_vertices[1]]
+}
+
+sub_domain3_vertices = [interface23_vertices[0],
+ interface23_vertices[1],
+ interface13_vertices[0]]
+
+subdomain3_outer_boundary_verts = None
+
+
+sub_domain4_vertices = [sub_domain0_vertices[0],
+ interface24_vertices[1],
+ interface34_vertices[1],
+ interface34_vertices[0],
+ interface45_vertices[0]]
+
+subdomain4_outer_boundary_verts = {
+ 0: [interface45_vertices[0],
+ sub_domain0_vertices[0],
+ interface24_vertices[1]]
+}
+
+sub_domain5_vertices = [interface45_vertices[0],
+ interface15_vertices[0],
+ interface15_vertices[1],
+ sub_domain0_vertices[3]]
+
+subdomain5_outer_boundary_verts = {
+ 0: [interface15_vertices[1],
+ sub_domain0_vertices[3],
+ interface45_vertices[0]]
+}
+
+# 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,
+ sub_domain3_vertices,
+ sub_domain4_vertices,
+ sub_domain5_vertices]
+# in the below list, index 0 corresponds to the 12 interface which has global
+# marker value 1
+interface_def_points = [interface13_vertices,
+ interface12_vertices,
+ interface23_vertices,
+ interface24_vertices,
+ interface34_vertices,
+ interface45_vertices,
+ interface15_vertices,]
+
+# adjacent_subdomains[i] contains the indices of the subdomains sharing the
+# interface i (i.e. given by interface_def_points[i]).
+adjacent_subdomains = [[1, 3], [1, 2], [2, 3], [2, 4], [3, 4], [4, 5], [1, 5]]
+
+# 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,
+ 3: subdomain3_outer_boundary_verts,
+ 4: subdomain4_outer_boundary_verts,
+ 5: subdomain5_outer_boundary_verts
+}
+
+isRichards = {
+ 1: True,
+ 2: False,
+ 3: False,
+ 4: False,
+ 5: True,
+ }
+
+# isRichards = {
+# 1: True,
+# 2: True,
+# 3: True,
+# 4: True,
+# 5: True,
+# 6: True
+# }
+
+# Dict of the form: { subdom_num : viscosity }
+viscosity = {
+ 1: {'wetting' :1,
+ 'nonwetting': 1/50},
+ 2: {'wetting' :1,
+ 'nonwetting': 1/50},
+ 3: {'wetting' :1,
+ 'nonwetting': 1/50},
+ 4: {'wetting' :1,
+ 'nonwetting': 1/50},
+ 5: {'wetting' :1,
+ 'nonwetting': 1/50},
+}
+
+# Dict of the form: { subdom_num : density }
+densities = {
+ 1: {'wetting': 997.0, #997
+ 'nonwetting': 1.225}, #1}, #1.225},
+ 2: {'wetting': 997.0, #997
+ 'nonwetting': 1.225}, #1.225},
+ 3: {'wetting': 997.0, #997
+ 'nonwetting': 1.225}, #1.225},
+ 4: {'wetting': 997.0, #997
+ 'nonwetting': 1.225}, #1.225}
+ 5: {'wetting': 997.0, #997
+ 'nonwetting': 1.225}, #1.225},
+}
+gravity_acceleration = 9.81
+# porosities taken from
+# https://www.geotechdata.info/parameter/soil-porosity.html
+# Dict of the form: { subdom_num : porosity }
+porosity = {
+ 1: 0.2, #0.2, # Clayey gravels, clayey sandy gravels
+ 2: 0.2, #0.22, # Silty gravels, silty sandy gravels
+ 3: 0.2, #0.37, # Clayey sands
+ 4: 0.2, #0.2 # Silty or sandy clay
+ 5: 0.2, #
+}
+
+# subdom_num : subdomain L for L-scheme
+L = {
+ 1: {'wetting' :Lw1,
+ 'nonwetting': Lnw1},
+ 2: {'wetting' :Lw2,
+ 'nonwetting': Lnw2},
+ 3: {'wetting' :Lw3,
+ 'nonwetting': Lnw3},
+ 4: {'wetting' :Lw4,
+ 'nonwetting': Lnw4},
+ 5: {'wetting' :Lw5,
+ 'nonwetting': Lnw5},
+}
+
+
+# interface_num : lambda parameter for the L-scheme on that interface.
+# Note that interfaces are numbered starting from 0, because
+# adjacent_subdomains is a list and not a dict. Historic fuckup, I know
+# We have defined above as interfaces
+# # interface_vertices introduces a global numbering of interfaces.
+# interface_def_points = [interface13_vertices,
+# interface12_vertices,
+# interface23_vertices,
+# interface24_vertices,
+# interface34_vertices,
+# interface45_vertices,
+# interface15_vertices,]
+lambda_param = {
+ 0: {'wetting': lambda13_w,
+ 'nonwetting': lambda13_nw},#
+ 1: {'wetting': lambda12_w,
+ 'nonwetting': lambda12_nw},#
+ 2: {'wetting': lambda23_w,
+ 'nonwetting': lambda23_nw},#
+ 3: {'wetting': lambda24_w,
+ 'nonwetting': lambda24_nw},#
+ 4: {'wetting': lambda34_w,
+ 'nonwetting': lambda34_nw},#
+ 5: {'wetting': lambda45_w,
+ 'nonwetting': lambda45_nw},#
+ 6: {'wetting': lambda15_w,
+ 'nonwetting': lambda15_nw}#
+}
+
+
+# after Lewis, see pdf file
+intrinsic_permeability = {
+ 1: 0.01, # sand
+ 2: 0.01, # sand, there is a range
+ 3: 0.01, #10e-2, # clay has a range
+ 4: 0.01, #10e-3
+ 5: 0.01, #10e-2, # clay has a range
+ 6: 0.01, #10e-3
+}
+
+
+
+# relative permeabilty functions on subdomain 1
+def rel_perm1w(s):
+ # relative permeabilty wetting on subdomain1
+ return intrinsic_permeability[1]*s**2
+
+
+def rel_perm1nw(s):
+ # relative permeabilty nonwetting on subdomain1
+ return intrinsic_permeability[1]*(1-s)**2
+
+
+# relative permeabilty functions on subdomain 2
+def rel_perm2w(s):
+ # relative permeabilty wetting on subdomain2
+ return intrinsic_permeability[2]*s**3
+
+
+def rel_perm2nw(s):
+ # relative permeabilty nonwetting on subdomain2
+ return intrinsic_permeability[2]*(1-s)**3
+
+
+# relative permeabilty functions on subdomain 3
+def rel_perm3w(s):
+ # relative permeabilty wetting on subdomain3
+ return intrinsic_permeability[3]*s**3
+
+
+def rel_perm3nw(s):
+ # relative permeabilty nonwetting on subdomain3
+ return intrinsic_permeability[3]*(1-s)**3
+
+
+# relative permeabilty functions on subdomain 4
+def rel_perm4w(s):
+ # relative permeabilty wetting on subdomain4
+ return intrinsic_permeability[4]*s**3
+
+
+def rel_perm4nw(s):
+ # relative permeabilty nonwetting on subdomain4
+ return intrinsic_permeability[4]*(1-s)**3
+
+
+# relative permeabilty functions on subdomain 5
+def rel_perm5w(s):
+ # relative permeabilty wetting on subdomain5
+ return intrinsic_permeability[5]*s**2
+
+
+def rel_perm5nw(s):
+ # relative permeabilty nonwetting on subdomain5
+ return intrinsic_permeability[5]*(1-s)**2
+
+
+_rel_perm1w = ft.partial(rel_perm1w)
+_rel_perm1nw = ft.partial(rel_perm1nw)
+
+_rel_perm2w = ft.partial(rel_perm2w)
+_rel_perm2nw = ft.partial(rel_perm2nw)
+
+_rel_perm3w = ft.partial(rel_perm3w)
+_rel_perm3nw = ft.partial(rel_perm3nw)
+
+_rel_perm4w = ft.partial(rel_perm4w)
+_rel_perm4nw = ft.partial(rel_perm4nw)
+
+_rel_perm5w = ft.partial(rel_perm5w)
+_rel_perm5nw = ft.partial(rel_perm5nw)
+
+
+subdomain1_rel_perm = {
+ 'wetting': _rel_perm1w,
+ 'nonwetting': _rel_perm1nw
+}
+
+subdomain2_rel_perm = {
+ 'wetting': _rel_perm2w,
+ 'nonwetting': _rel_perm2nw
+}
+
+subdomain3_rel_perm = {
+ 'wetting': _rel_perm3w,
+ 'nonwetting': _rel_perm3nw
+}
+
+subdomain4_rel_perm = {
+ 'wetting': _rel_perm4w,
+ 'nonwetting': _rel_perm4nw
+}
+
+subdomain5_rel_perm = {
+ 'wetting': _rel_perm5w,
+ 'nonwetting': _rel_perm5nw
+}
+
+
+# dictionary of relative permeabilties on all domains.
+relative_permeability = {
+ 1: subdomain1_rel_perm,
+ 2: subdomain2_rel_perm,
+ 3: subdomain3_rel_perm,
+ 4: subdomain4_rel_perm,
+ 5: subdomain5_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 intrinsic_permeability[1]*2*s
+
+
+def rel_perm1nw_prime(s):
+ # relative permeabilty on subdomain1
+ return -1*intrinsic_permeability[1]*2*(1-s)
+
+
+def rel_perm2w_prime(s):
+ # relative permeabilty on subdomain2
+ return intrinsic_permeability[2]*3.0*s**2
+
+
+def rel_perm2nw_prime(s):
+ # relative permeabilty on subdomain2
+ return -1*intrinsic_permeability[2]*3.0*(1-s)**2
+
+
+# definition of the derivatives of the relative permeabilities
+# relative permeabilty functions on subdomain 3
+def rel_perm3w_prime(s):
+ # relative permeabilty on subdomain3
+ return intrinsic_permeability[3]*3.0*s**2
+
+
+def rel_perm3nw_prime(s):
+ # relative permeabilty on subdomain3
+ return -1*intrinsic_permeability[3]*3.0*(1-s)**2
+
+
+# definition of the derivatives of the relative permeabilities
+# relative permeabilty functions on subdomain 4
+def rel_perm4w_prime(s):
+ # relative permeabilty on subdomain4
+ return intrinsic_permeability[4]*3.0*s**2
+
+
+def rel_perm4nw_prime(s):
+ # relative permeabilty on subdomain4
+ return -1*intrinsic_permeability[4]*3.0*(1-s)**2
+
+
+# definition of the derivatives of the relative permeabilities
+# relative permeabilty functions on subdomain 5
+def rel_perm5w_prime(s):
+ # relative permeabilty on subdomain5
+ return intrinsic_permeability[5]*2.0*s
+
+
+def rel_perm5nw_prime(s):
+ # relative permeabilty on subdomain5
+ return -1*intrinsic_permeability[5]*2.0*(1-s)
+
+
+_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)
+_rel_perm3w_prime = ft.partial(rel_perm3w_prime)
+_rel_perm3nw_prime = ft.partial(rel_perm3nw_prime)
+_rel_perm4w_prime = ft.partial(rel_perm4w_prime)
+_rel_perm4nw_prime = ft.partial(rel_perm4nw_prime)
+_rel_perm5w_prime = ft.partial(rel_perm5w_prime)
+_rel_perm5nw_prime = ft.partial(rel_perm5nw_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
+}
+
+subdomain3_rel_perm_prime = {
+ 'wetting': _rel_perm3w_prime,
+ 'nonwetting': _rel_perm3nw_prime
+}
+
+
+subdomain4_rel_perm_prime = {
+ 'wetting': _rel_perm4w_prime,
+ 'nonwetting': _rel_perm4nw_prime
+}
+
+subdomain5_rel_perm_prime = {
+ 'wetting': _rel_perm5w_prime,
+ 'nonwetting': _rel_perm5nw_prime
+}
+
+
+# dictionary of relative permeabilties on all domains.
+ka_prime = {
+ 1: subdomain1_rel_perm_prime,
+ 2: subdomain2_rel_perm_prime,
+ 3: subdomain3_rel_perm_prime,
+ 4: subdomain4_rel_perm_prime,
+ 5: subdomain5_rel_perm_prime
+}
+
+
+
+# this function needs to be monotonically decreasing in the capillary_pressure.
+# since in the richards case pc=-pw, this becomes as a function of pw a mono
+# tonically INCREASING function like in our Richards-Richards paper. However
+# since we unify the treatment in the code for Richards and two-phase, we need
+# the same requierment
+# for both cases, two-phase and Richards.
+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=2),
+ 5: 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=2),
+ 5: 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=2),
+ 5: 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': -7.0 - (1.0 + t*t)*(1.0 + x*x + y*y),
+ 'nonwetting': 0*t },
+ 2: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x),
+ 'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
+ 3: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x),
+ 'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
+ 4: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x),
+ 'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
+ 5: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x + y*y),
+ 'nonwetting': 0*t },
+}
+
+pc_e_sym = dict()
+for subdomain, isR in isRichards.items():
+ if isR:
+ pc_e_sym.update({subdomain: -p_e_sym[subdomain]['wetting']})
+ else:
+ pc_e_sym.update(
+ {subdomain: p_e_sym[subdomain]['nonwetting']
+ - p_e_sym[subdomain]['wetting']}
+ )
+
+
+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]}
+ )
+
+
+# LOG FILE OUTPUT #############################################################
+# read this file and print it to std out. This way the simulation can produce a
+# log file with ./TP-R-layered_soil.py | tee simulation.log
+f = open(thisfile, 'r')
+print(f.read())
+f.close()
+
+
+# RUN #########################################################################
+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,
+ gravity_acceleration=gravity_acceleration,
+ 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, error_dict in subdomain_output['errornorm'].items():
+ filename = output_dir \
+ + "subdomain{}".format(subdomain_index)\
+ + "-space-time-errornorm-{}-phase.csv".format(phase)
+ # for errortype, errornorm in error_dict.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 norm_type, errornorm in error_dict.items():
+ data_dict.update(
+ {norm_type: errornorm}
+ )
+ errors = pd.DataFrame(data_dict, index=[mesh_resolution])
+ # check if file exists
+ if os.path.isfile(filename) is 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/Two-phase-Richards/multi-patch/five_patch_domain_with_inner_patch/run-simulation b/Two-phase-Richards/multi-patch/five_patch_domain_with_inner_patch/run-simulation
new file mode 100755
index 0000000000000000000000000000000000000000..0eb497502a082a0fec07a5449b1fe946d59c8cc7
--- /dev/null
+++ b/Two-phase-Richards/multi-patch/five_patch_domain_with_inner_patch/run-simulation
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+[ $# -eq 0 ] && { echo "Usage: $0 simulation_file [logfile_name]"; exit 1; }
+
+SIMULATION_FILE=$1
+SIMULATION=${SIMULATION_FILE%.py}
+LOGFILE_DEFAULT="$SIMULATION.log"
+
+DATE=$(date -I)
+LOGFILE=${2:-$DATE-$LOGFILE_DEFAULT}
+
+GREETING="Simulation $SIMULATION is run on $DATE by $USER"
+
+echo $GREETING
+echo "running $SIMULATION_FILE | tee $LOGFILE"
+./$SIMULATION_FILE | tee $LOGFILE
diff --git a/Two-phase-Richards/multi-patch/layered_soil_with_inner_patch/TP-R-layered_soil_with_inner_patch-all-params-one-finer-dt.py b/Two-phase-Richards/multi-patch/layered_soil_with_inner_patch/TP-R-layered_soil_with_inner_patch-all-params-one-finer-dt.py
old mode 100644
new mode 100755
diff --git a/Two-phase-Richards/multi-patch/layered_soil_with_inner_patch/TP-R-layered_soil_with_inner_patch-realistic.py b/Two-phase-Richards/multi-patch/layered_soil_with_inner_patch/TP-R-layered_soil_with_inner_patch-realistic.py
index ec5f1d54cfddcacaf263095bd38c2023fb071213..d81858530db4e5bedfa155611eedc707a5585338 100755
--- a/Two-phase-Richards/multi-patch/layered_soil_with_inner_patch/TP-R-layered_soil_with_inner_patch-realistic.py
+++ b/Two-phase-Richards/multi-patch/layered_soil_with_inner_patch/TP-R-layered_soil_with_inner_patch-realistic.py
@@ -5,12 +5,8 @@ This program sets up an LDD simulation
"""
import dolfin as df
-# import mshr
-# import numpy as np
import sympy as sym
-# import typing as tp
import functools as ft
-# import domainPatch as dp
import LDDsimulation as ldd
import helpers as hlp
import datetime
@@ -34,8 +30,8 @@ sym.init_printing()
# solver_tol = 6E-7
use_case = "TP-R-layered-soil-with-inner-patch-realistic"
# name of this very file. Needed for log output.
-thisfile = "TP-R-layered_soil_with_inner_patch.py"
-max_iter_num = 300
+thisfile = "TP-R-layered_soil_with_inner_patch-realistic.py"
+max_iter_num = 700
FEM_Lagrange_degree = 1
mesh_study = False
resolutions = {
@@ -43,7 +39,7 @@ resolutions = {
# 2: 2e-6, # h=1.1180
# 4: 2e-6, # h=0.5590
# 8: 2e-6, # h=0.2814
- 16: 2e-6, # h=0.1412
+ 16: 8e-6, # h=0.1412
# 32: 2e-6,
# 64: 2e-6,
# 128: 2e-6
@@ -835,18 +831,18 @@ t = sym.symbols('t', positive=True)
p_e_sym = {
- 1: {'wetting': -5.0 - (1.0 + t*t)*(1.0 + x*x + y*y),
- 'nonwetting': (-1 -t*(1.1 + y + x**2)) },
- 2: {'wetting': -5.0 - (1.0 + t*t)*(1.0 + x*x + y*y),
- 'nonwetting': (-1 -t*(1.1 + y + x**2)) },
- 3: {'wetting': (-5.0 - (1.0 + t*t)*(1.0 + x*x)),
- 'nonwetting': (-1 -t*(1 + x**2) - sym.sqrt(2+t**2)*(1+y)*y**2) },
- 4: {'wetting': (-5.0 - (1.0 + t*t)*(1.0 + x*x)),
- 'nonwetting': (-1 -t*(1 + x**2) - sym.sqrt(2+t**2)*(1+y)*y**2) },
- 5: {'wetting': (-5.0 - (1.0 + t*t)*(1.0 + x*x)),
- 'nonwetting': (-1 -t*(1 + x**2) - sym.sqrt(2+t**2)*(1+y)*y**2) },
- 6: {'wetting': (-5.0 - (1.0 + t*t)*(1.0 + x*x)),
- 'nonwetting': (-1 -t*(1 + x**2) - sym.sqrt(2+t**2)*(1+y)*y**2) },
+ 1: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x + y*y),
+ 'nonwetting': 0*t },
+ 2: {'wetting': -7.0 - (1.0 + t*t)*(1.0 + x*x + y*y),
+ 'nonwetting': 0*t },
+ 3: {'wetting': (-7.0 - (1.0 + t*t)*(1.0 + x*x)),
+ 'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
+ 4: {'wetting': (-7.0 - (1.0 + t*t)*(1.0 + x*x)),
+ 'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
+ 5: {'wetting': (-7.0 - (1.0 + t*t)*(1.0 + x*x)),
+ 'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
+ 6: {'wetting': (-7.0 - (1.0 + t*t)*(1.0 + x*x)),
+ 'nonwetting': (-1.0 -t*(1.0 + x**2) - sym.sqrt(2+t**2)**2)*y**2 },
}
pc_e_sym = dict()