From 16a71074c306f6c7be2ac446495f244ea6f9feb7 Mon Sep 17 00:00:00 2001
From: David Seus <david.seus@ians.uni-stuttgart.de>
Date: Sat, 25 May 2019 17:55:58 +0200
Subject: [PATCH] fix _is_on_line_segment_method
---
LDDsimulation/boundary_and_interface.py | 13 +-
.../RR-multi-patch-with-gravity.py | 6 +-
.../TP-TP-layered_soil_with_inner_patch.py | 569 ++++++++++++++++++
TP-TP-layered-soil-case/TP-TP-layered_soil.py | 24 +-
4 files changed, 591 insertions(+), 21 deletions(-)
create mode 100755 TP-TP-layered-soil-case-with-inner-patch/TP-TP-layered_soil_with_inner_patch.py
diff --git a/LDDsimulation/boundary_and_interface.py b/LDDsimulation/boundary_and_interface.py
index 76b78db..48f6ea7 100644
--- a/LDDsimulation/boundary_and_interface.py
+++ b/LDDsimulation/boundary_and_interface.py
@@ -177,11 +177,6 @@ class BoundaryPart(df.SubDomain):
xmax = max(p1[0], p2[0])
ymin = min(p1[1], p2[1])
ymax = max(p1[1], p2[1])
- # print(f"test if point {p} is on line segment between {p1} or {p2}")
- # check if p == p1 or p == p2
- if np.fabs((p[0] - xmax)*(p[0] - xmin)) < tol and np.fabs((p[1] - ymax)*(p[1] - ymin)) < tol:
- #print(f"point {p} is close to either {p1} or {p2}")
- return True
# check there holds p1[0] < p[0] < p2[0]. If not, p cannot be on the line segment
# same needs to be done for p1[1] < p[1] < p2[1]
@@ -609,16 +604,24 @@ class Interface(BoundaryPart):
# of edges on the boundary. We need the number of nodes, however.
number_of_interface_vertices = sum(interface_marker.array() == interface_marker_value) + 1
+ print(f"interface marker array",interface_marker.array() == interface_marker_value)
+ print(f"facets marked by interface marker", interface_marker.array())
+ print(f"interface{self.global_index} has coordinates {self.coordinates(interface_marker, interface_marker_value)}")
+ # for cell in interface_marker[interface_marker.array() == interface_marker_value]:
+ # print(cell.get_cell_data())
# print(f"\nDetermined number of interface vertices as {number_of_interface_vertices}")
# we need one mesh_dimension + 1 columns to store the the index of the node.
vertex_indices = np.zeros(shape = number_of_interface_vertices, dtype=int)
# print(f"allocated array for vertex_indices\n", vertex_indices) #
interface_vertex_number = 0
# mesh_vertex_index = 0
+ print(f"\n we are one interface{self.global_index}",
+ f" we determined {number_of_interface_vertices} interface vertices.")
for vert_num, x in enumerate(mesh_coordinates):
if self._is_on_boundary_part(x):
# print(f"Vertex {x} with index {vert_num} is on interface")
# print(f"interface_vertex_number = {interface_vertex_number}")
+ print(f"dfPoint = ({x}) is on interface{self.global_index}")
vertex_indices[interface_vertex_number] = vert_num
interface_vertex_number += 1
diff --git a/RR-multi-patch-plus-gravity/RR-multi-patch-with-gravity.py b/RR-multi-patch-plus-gravity/RR-multi-patch-with-gravity.py
index d1375f3..16d3d63 100755
--- a/RR-multi-patch-plus-gravity/RR-multi-patch-with-gravity.py
+++ b/RR-multi-patch-plus-gravity/RR-multi-patch-with-gravity.py
@@ -15,15 +15,15 @@ sym.init_printing()
# ----------------------------------------------------------------------------#
# ------------------- MESH ---------------------------------------------------#
# ----------------------------------------------------------------------------#
-mesh_resolution = 30
+mesh_resolution = 3
# ----------------------------------------:-------------------------------------#
# ------------------- TIME ---------------------------------------------------#
# ----------------------------------------------------------------------------#
timestep_size = 0.01
-number_of_timesteps = 500
+number_of_timesteps = 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 = 11
+number_of_timesteps_to_analyse = 0
starttime = 0
diff --git a/TP-TP-layered-soil-case-with-inner-patch/TP-TP-layered_soil_with_inner_patch.py b/TP-TP-layered-soil-case-with-inner-patch/TP-TP-layered_soil_with_inner_patch.py
new file mode 100755
index 0000000..b729462
--- /dev/null
+++ b/TP-TP-layered-soil-case-with-inner-patch/TP-TP-layered_soil_with_inner_patch.py
@@ -0,0 +1,569 @@
+#!/usr/bin/python3
+"""This program sets up a domain together with a decomposition into subdomains
+modelling layered soil. This is used for our LDD article with tp-tp and tp-r
+coupling.
+
+Along with the subdomains and the mesh domain markers are set upself.
+The resulting mesh is saved into files for later use.
+"""
+
+#!/usr/bin/python3
+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
+
+# init sympy session
+sym.init_printing()
+
+# ----------------------------------------------------------------------------#
+# ------------------- MESH ---------------------------------------------------#
+# ----------------------------------------------------------------------------#
+mesh_resolution = 5
+# ----------------------------------------:-----------------------------------#
+# ------------------- TIME ---------------------------------------------------#
+# ----------------------------------------------------------------------------#
+timestep_size = 0.003
+number_of_timesteps = 300
+# 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 = 11
+starttime = 0
+
+l_param_w = 80
+l_param_nw = 120
+
+# global domain
+subdomain0_vertices = [df.Point(0.0,0.0), #
+ df.Point(13.0,0.0),#
+ df.Point(13.0,8.0),#
+ df.Point(0.0,8.0)]
+
+interface12_vertices = [df.Point(0.0, 7.0),
+ df.Point(9.0, 7.0),
+ df.Point(10.5, 7.5),
+ df.Point(12.0, 7.0),
+ df.Point(13.0, 6.5)]
+# subdomain1.
+subdomain1_vertices = [interface12_vertices[0],
+ interface12_vertices[1],
+ interface12_vertices[2],
+ interface12_vertices[3],
+ interface12_vertices[4], # southern boundary, 12 interface
+ subdomain0_vertices[2], # eastern boundary, outer boundary
+ subdomain0_vertices[3]] # northern boundary, outer on_boundary
+
+# 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[4], #
+ subdomain0_vertices[2], # eastern boundary, outer boundary
+ subdomain0_vertices[3],
+ interface12_vertices[0]]
+}
+
+
+# interface23
+interface23_vertices = [df.Point(0.0, 5.0),
+ df.Point(3.0, 5.0),
+ # df.Point(6.5, 4.5),
+ df.Point(6.5, 5.0),
+ df.Point(9.5, 5.0),
+ # df.Point(11.5, 3.5),
+ # df.Point(13.0, 3)
+ df.Point(11.5, 5.0),
+ df.Point(13.0, 5.0)
+ ]
+
+#subdomain1
+subdomain2_vertices = [interface23_vertices[0],
+ interface23_vertices[1],
+ interface23_vertices[2],
+ interface23_vertices[3],
+ interface23_vertices[4],
+ interface23_vertices[5], # southern boundary, 23 interface
+ subdomain1_vertices[4], # eastern boundary, outer boundary
+ subdomain1_vertices[3],
+ subdomain1_vertices[2],
+ subdomain1_vertices[1],
+ subdomain1_vertices[0] ] # northern boundary, 12 interface
+
+subdomain2_outer_boundary_verts = {
+ 0: [interface23_vertices[5],
+ subdomain1_vertices[4]],
+ 1: [subdomain1_vertices[0],
+ interface23_vertices[0]]
+}
+
+
+
+interface32_vertices = [interface23_vertices[2],
+ interface23_vertices[1],
+ interface23_vertices[0]]
+
+interface34_vertices = [df.Point(4.0, 2.0),
+ df.Point(4.7, 3.0),
+ interface23_vertices[2]]
+# interface36
+interface36_vertices = [df.Point(0.0, 2.0),
+ df.Point(4.0, 2.0)]
+
+subdomain3_vertices = [interface36_vertices[0],
+ interface36_vertices[1],
+ interface34_vertices[0],
+ interface34_vertices[1],
+ interface34_vertices[2]
+ interface32_vertices[0],
+ interface32_vertices[1],
+ interface32_vertices[2]
+ ]
+
+interface46_vertices = [df.Point(4.0, 2.0),
+ df.Point(9.0, 2.5)]
+
+interface46_vertices = [df.Point(9.0, 2.5),
+ df.Point(10.5, 2.0),
+ df.Point(13.0, 1.5)]
+
+# subdomain3
+subdomain3_vertices = [interface34_vertices[0],
+ interface34_vertices[1],
+ interface34_vertices[2],
+ interface34_vertices[3],
+ interface34_vertices[4], # southern boundary, 34 interface
+ subdomain2_vertices[5], # eastern boundary, outer boundary
+ subdomain2_vertices[4],
+ subdomain2_vertices[3],
+ subdomain2_vertices[2],
+ subdomain2_vertices[1],
+ subdomain2_vertices[0] ] # northern boundary, 23 interface
+
+
+
+
+subdomain3_outer_boundary_verts = {
+ 0: [interface34_vertices[4],
+ subdomain2_vertices[5]],
+ 1: [subdomain2_vertices[0],
+ interface34_vertices[0]]
+}
+
+# subdomain4
+subdomain4_vertices = [subdomain0_vertices[0],
+ subdomain0_vertices[1], # southern boundary, outer boundary
+ subdomain3_vertices[4],# eastern boundary, outer boundary
+ subdomain3_vertices[3],
+ subdomain3_vertices[2],
+ subdomain3_vertices[1],
+ subdomain3_vertices[0] ] # northern boundary, 34 interface
+
+subdomain4_outer_boundary_verts = {
+ 0: [subdomain4_vertices[6],
+ subdomain4_vertices[0],
+ subdomain4_vertices[1],
+ subdomain4_vertices[2]]
+}
+
+
+subdomain_def_points = [subdomain0_vertices,#
+ subdomain1_vertices,#
+ subdomain2_vertices,#
+ subdomain3_vertices,#
+ subdomain4_vertices
+ ]
+
+
+# interface_vertices introduces a global numbering of interfaces.
+interface_def_points = [interface12_vertices, interface23_vertices, interface34_vertices]
+adjacent_subdomains = [[1,2], [2,3], [3,4]]
+
+# 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
+}
+
+isRichards = {
+ 1: False,
+ 2: False,
+ 3: False,
+ 4: False
+ }
+
+# 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},
+}
+
+# Dict of the form: { subdom_num : density }
+densities = {
+ 1: {'wetting': 997,
+ 'nonwetting': 1.225},
+ 2: {'wetting': 997,
+ 'nonwetting': 1.225},
+ 3: {'wetting': 997,
+ 'nonwetting': 1.225},
+ 4: {'wetting': 997,
+ 'nonwetting': 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, # Clayey gravels, clayey sandy gravels
+ 2: 0.22, # Silty gravels, silty sandy gravels
+ 3: 0.37, # Clayey sands
+ 4: 0.2 # Silty or sandy clay
+}
+
+# subdom_num : subdomain L for L-scheme
+L = {
+ 1: {'wetting' :0.3,
+ 'nonwetting': 0.25},
+ 2: {'wetting' :0.3,
+ 'nonwetting': 0.25},
+ 3: {'wetting' :0.3,
+ 'nonwetting': 0.25},
+ 4: {'wetting' :0.3,
+ 'nonwetting': 0.25}
+}
+
+# subdom_num : lambda parameter for the L-scheme
+lambda_param = {
+ 1: {'wetting': l_param_w,
+ 'nonwetting': l_param_nw},#
+ 2: {'wetting': l_param_w,
+ 'nonwetting': l_param_nw},#
+ 3: {'wetting': l_param_w,
+ 'nonwetting': l_param_nw},#
+ 4: {'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
+
+
+## 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)**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)
+
+subdomain1_rel_perm = {
+ 'wetting': _rel_perm1w,#
+ 'nonwetting': _rel_perm1nw
+}
+
+subdomain2_rel_perm = {
+ 'wetting': _rel_perm2w,#
+ 'nonwetting': _rel_perm2nw
+}
+
+# _rel_perm3 = ft.partial(rel_perm2)
+# subdomain3_rel_perm = subdomain2_rel_perm.copy()
+#
+# _rel_perm4 = ft.partial(rel_perm1)
+# subdomain4_rel_perm = subdomain1_rel_perm.copy()
+
+# dictionary of relative permeabilties on all domains.
+relative_permeability = {
+ 1: subdomain1_rel_perm,
+ 2: subdomain1_rel_perm,
+ 3: subdomain2_rel_perm,
+ 4: 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 2*(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)
+
+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: subdomain1_rel_perm_prime,
+ 3: subdomain2_rel_perm_prime,
+ 4: subdomain2_rel_perm_prime
+}
+
+
+
+# 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
+# this function needs to be monotonically decreasing in the capillary pressure pc.
+# 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, 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 saturation_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 saturation_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(saturation_sym, n_index=3, alpha=0.001),
+ 2: ft.partial(saturation_sym, n_index=3, alpha=0.001),
+ 3: ft.partial(saturation_sym, n_index=6, alpha=0.001),
+ 4: ft.partial(saturation_sym, n_index=6, alpha=0.001)
+}
+
+S_pc_sym_prime = {
+ 1: ft.partial(saturation_sym_prime, n_index=3, alpha=0.001),
+ 2: ft.partial(saturation_sym_prime, n_index=3, alpha=0.001),
+ 3: ft.partial(saturation_sym_prime, n_index=6, alpha=0.001),
+ 4: ft.partial(saturation_sym_prime, n_index=6, alpha=0.001)
+}
+
+sat_pressure_relationship = {
+ 1: ft.partial(saturation, n_index=3, alpha=0.001),
+ 2: ft.partial(saturation, n_index=3, alpha=0.001),
+ 3: ft.partial(saturation, n_index=6, alpha=0.001),
+ 4: ft.partial(saturation, n_index=6, alpha=0.001)
+}
+
+
+#############################################
+# 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': 1.0 - (1.0 + t*t)*(10.0 + x*x + (y-5.0)*(y-5.0)),
+ 'nonwetting': - 2 - t*(1 + (y-5.0) + x**2)**2 -sym.sqrt(2+t**2)*(1 + (y-5.0)) },
+ 2: {'wetting': 1.0 - (1.0 + t*t)*(10.0 + x*x + (y-5.0)*(y-5.0)),
+ 'nonwetting': - 2 - t*(1 + (y-5.0) + x**2)**2 -sym.sqrt(2+t**2)*(1 + (y-5.0))},
+ 3: {'wetting': 1.0 - (1.0 + t*t)*(10.0 + x*x + (y-5.0)*(y-5.0)*3*sym.sin(-2*t+2*x)*sym.sin(1/2*y-1.2*t)),
+ 'nonwetting': - 2 - t*(1 + x**2)**2 -sym.sqrt(2+t**2)},
+ 4: {'wetting': 1.0 - (1.0 + t*t)*(10.0 + x*x + (y-5.0)*(y-5.0)*3*sym.sin(-2*t+2*x)*sym.sin(1/2*y-1.2*t)),
+ 'nonwetting': - 2 - t*(1 + x**2)**2 -sym.sqrt(2+t**2)}
+}
+
+pc_e_sym = {
+ 1: p_e_sym[1]['nonwetting'] - p_e_sym[1]['wetting'],
+ 2: p_e_sym[2]['nonwetting'] - p_e_sym[2]['wetting'],
+ 3: p_e_sym[3]['nonwetting'] - p_e_sym[3]['wetting'],
+ 4: p_e_sym[4]['nonwetting'] - p_e_sym[4]['wetting']
+}
+
+# turn above symbolic code into exact solution for dolphin and
+# construct the rhs that matches the above exact solution.
+dtS = dict()
+div_flux = dict()
+source_expression = dict()
+exact_solution = dict()
+initial_condition = dict()
+for subdomain, isR in isRichards.items():
+ dtS.update({subdomain: dict()})
+ div_flux.update({subdomain: dict()})
+ source_expression.update({subdomain: dict()})
+ exact_solution.update({subdomain: dict()})
+ initial_condition.update({subdomain: dict()})
+ if isR:
+ subdomain_has_phases = ["wetting"]
+ else:
+ subdomain_has_phases = ["wetting", "nonwetting"]
+
+ # conditional for S_pc_prime
+ pc = pc_e_sym[subdomain]
+ dtpc = sym.diff(pc, t, 1)
+ dxpc = sym.diff(pc, x, 1)
+ dypc = sym.diff(pc, y, 1)
+ S = sym.Piecewise((S_pc_sym[subdomain](pc), pc > 0), (1, True))
+ dS = sym.Piecewise((S_pc_sym_prime[subdomain](pc), pc > 0), (0, True))
+ for phase in subdomain_has_phases:
+ # Turn above symbolic expression for exact solution into c code
+ exact_solution[subdomain].update(
+ {phase: sym.printing.ccode(p_e_sym[subdomain][phase])}
+ )
+ # save the c code for initial conditions
+ initial_condition[subdomain].update(
+ {phase: sym.printing.ccode(p_e_sym[subdomain][phase].subs(t, 0))}
+ )
+ if phase == "nonwetting":
+ dS = -dS
+ dtS[subdomain].update(
+ {phase: porosity[subdomain]*dS*dtpc}
+ )
+ pa = p_e_sym[subdomain][phase]
+ dxpa = sym.diff(pa, x, 1)
+ dxdxpa = sym.diff(pa, x, 2)
+ dypa = sym.diff(pa, y, 1)
+ dydypa = sym.diff(pa, y, 2)
+ mu = viscosity[subdomain][phase]
+ ka = relative_permeability[subdomain][phase]
+ dka = ka_prime[subdomain][phase]
+ rho = densities[subdomain][phase]
+ g = gravity_acceleration
+
+ if phase == "nonwetting":
+ # x part of div(flux) for nonwetting
+ dxdxflux = -1/mu*dka(1-S)*dS*dxpc*dxpa + 1/mu*dxdxpa*ka(1-S)
+ # y part of div(flux) for nonwetting
+ dydyflux = -1/mu*dka(1-S)*dS*dypc*(dypa - rho*g) \
+ + 1/mu*dydypa*ka(1-S)
+ else:
+ # x part of div(flux) for wetting
+ dxdxflux = 1/mu*dka(S)*dS*dxpc*dxpa + 1/mu*dxdxpa*ka(S)
+ # y part of div(flux) for wetting
+ dydyflux = 1/mu*dka(S)*dS*dypc*(dypa - rho*g) + 1/mu*dydypa*ka(S)
+ div_flux[subdomain].update({phase: dxdxflux + dydyflux})
+ contructed_rhs = dtS[subdomain][phase] - div_flux[subdomain][phase]
+ source_expression[subdomain].update(
+ {phase: sym.printing.ccode(contructed_rhs)}
+ )
+ # print(f"source_expression[{subdomain}][{phase}] =", source_expression[subdomain][phase])
+
+# 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]}
+ )
+
+write_to_file = {
+ 'meshes_and_markers': True,
+ 'L_iterations': True
+}
+
+# initialise LDD simulation class
+simulation = ldd.LDDsimulation(tol=1E-14, debug=True, LDDsolver_tol=1E-7)
+simulation.set_parameters(output_dir="./output/",
+ 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,
+ timestep_size=timestep_size,
+ sources=source_expression,
+ initial_conditions=initial_condition,
+ dirichletBC_expression_strings=dirichletBC,
+ exact_solution=exact_solution,
+ densities=densities,
+ include_gravity=True,
+ write2file=write_to_file,
+ )
+
+simulation.initialise()
+# print(simulation.__dict__)
+simulation.run()
+# simulation.LDDsolver(time=0, debug=True, analyse_timestep=True)
+# df.info(parameters, True)
diff --git a/TP-TP-layered-soil-case/TP-TP-layered_soil.py b/TP-TP-layered-soil-case/TP-TP-layered_soil.py
index 7ecf9a7..2cfac5c 100755
--- a/TP-TP-layered-soil-case/TP-TP-layered_soil.py
+++ b/TP-TP-layered-soil-case/TP-TP-layered_soil.py
@@ -23,19 +23,19 @@ sym.init_printing()
# ----------------------------------------------------------------------------#
# ------------------- MESH ---------------------------------------------------#
# ----------------------------------------------------------------------------#
-mesh_resolution = 4
+mesh_resolution = 20
# ----------------------------------------:-------------------------------------#
# ------------------- TIME ---------------------------------------------------#
# ----------------------------------------------------------------------------#
-timestep_size = 0.005
-number_of_timesteps = 30
+timestep_size = 0.003
+number_of_timesteps = 300
# 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 = 11
starttime = 0
-l_param_w = 40
-l_param_nw = l_param_w
+l_param_w = 80
+l_param_nw = 120
# global domain
subdomain0_vertices = [df.Point(0.0,0.0), #
@@ -213,13 +213,13 @@ porosity = {
# subdom_num : subdomain L for L-scheme
L = {
- 1: {'wetting' :0.25,
+ 1: {'wetting' :0.3,
'nonwetting': 0.25},
- 2: {'wetting' :0.25,
+ 2: {'wetting' :0.3,
'nonwetting': 0.25},
- 3: {'wetting' :0.25,
+ 3: {'wetting' :0.3,
'nonwetting': 0.25},
- 4: {'wetting' :0.25,
+ 4: {'wetting' :0.3,
'nonwetting': 0.25}
}
@@ -492,13 +492,11 @@ dirichletBC = dict()
# 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()})
- # if subdomain has no outer boundary, outer_boundary_def_points[subdomain] is None
-
- if outer_boundary_def_points[subdomain] is not None:
# 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():
@@ -512,7 +510,7 @@ write_to_file = {
}
# initialise LDD simulation class
-simulation = ldd.LDDsimulation(tol=1E-14, debug=False, LDDsolver_tol=1E-9)
+simulation = ldd.LDDsimulation(tol=1E-14, debug=True, LDDsolver_tol=1E-7)
simulation.set_parameters(output_dir="./output/",
subdomain_def_points=subdomain_def_points,
isRichards=isRichards,
--
GitLab