Select Git revision
function.jl
domainSubstructuring.py 22.98 KiB
"""Class domainSubstructuring.
Provides the base class and examples for defining substructurings for a
the simulation domain
"""
import dolfin as df
import helpers as hlp
class domainSubstructuring(object):
"""Base class for substructuring of a domain."""
def __init__(self):
"""Set all variables."""
hlp.print_once("\n DD Substructuring:\n")
self.interface_def_points = None
self.adjacent_subdomains = None
self.subdomain_def_points = None
self.outer_boundary_def_points = None
def __interface_def_points(self):
"""Set self._interface_def_points."""
raise(NotImplementedError())
def __adjacent_subdomains(self):
"""Set self._adjacent_subdomains."""
raise(NotImplementedError())
def __subdomain_def_points(self):
"""Set self._subdomain_def_points."""
raise(NotImplementedError())
def __outer_boundary_def_points(self):
"""Set self._outer_boundary_def_points."""
raise(NotImplementedError())
class twoSoilLayers(domainSubstructuring):
"""layered soil substructuring with inner patch."""
def __init__(self):
"""Layered soil case with inner patch."""
super().__init__()
hlp.print_once("\n Layered Soil with inner Patch:\n")
# global domain
self.__subdomain0_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)
]
self.__interface_def_points()
self.__adjacent_subdomains()
self.__subdomain_def_points()
self.__outer_boundary_def_points()
def __interface_def_points(self):
"""Set self._interface_def_points."""
self.__interface12_vertices = [
df.Point(-1.0, 0.0),
df.Point(1.0, 0.0)
]
# interface_vertices introduces a global numbering of interfaces.
self.interface_def_points = [
self.__interface12_vertices,
]
def __adjacent_subdomains(self):
"""Set self._adjacent_subdomains."""
self.adjacent_subdomains = [
[1, 2],
]
def __subdomain_def_points(self):
"""Set self._subdomain_def_points."""
# subdomain1.
self.__subdomain1_vertices = [
self.__interface12_vertices[0],
self.__interface12_vertices[1],
self.__subdomain0_vertices[2],
self.__subdomain0_vertices[3]
]
# subdomain2
self.__subdomain2_vertices = [
self.__subdomain0_vertices[0],
self.__subdomain0_vertices[1],
self.__interface12_vertices[1],
self.__interface12_vertices[0]]
self.subdomain_def_points = [
self.__subdomain0_vertices,
self.__subdomain1_vertices,
self.__subdomain2_vertices,
]
def __outer_boundary_def_points(self):
"""Set self._outer_boundary_def_points."""
# 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
self.__subdomain1_outer_boundary_verts = {
0: [self.__interface12_vertices[1],
self.__subdomain0_vertices[2],
self.__subdomain0_vertices[3],
self.__interface12_vertices[0]]
}
self.__subdomain2_outer_boundary_verts = {
0: [self.__interface12_vertices[0],
self.__subdomain0_vertices[0],
self.__subdomain0_vertices[1],
self.__interface12_vertices[1]]
}
# if a subdomain has no outer boundary write None instead, i.e.
# i: None
# if i is the index of the inner subdomain.
self.outer_boundary_def_points = {
# subdomain number
1: self.__subdomain1_outer_boundary_verts,
2: self.__subdomain2_outer_boundary_verts,
}
class layeredSoil(domainSubstructuring):
"""layered soil substructuring with inner patch."""
def __init__(self):
"""Layered soil case with inner patch."""
super().__init__()
hlp.print_once("\n Layered Soil with inner Patch:\n")
# global domain
self.__subdomain0_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)
]
self.__interface_def_points()
self.__adjacent_subdomains()
self.__subdomain_def_points()
self.__outer_boundary_def_points()
def __interface_def_points(self):
"""Set self._interface_def_points."""
self.__interface12_vertices = [
df.Point(-1.0, 0.8),
df.Point(0.3, 0.8),
df.Point(0.5, 0.9),
df.Point(0.8, 0.7),
df.Point(1.0, 0.65)
]
# interface23
self.__interface23_vertices = [
df.Point(-1.0, 0.0),
# df.Point(-0.35, 0.0),
# df.Point(0.0, 0.0),
# df.Point(0.5, 0.0),
# df.Point(0.85, 0.0),
df.Point(1.0, 0.0)
]
self.__interface34_vertices = [
df.Point(-1.0, -0.6),
df.Point(-0.6, -0.45),
df.Point(0.3, -0.25),
df.Point(0.65, -0.6),
df.Point(1.0, -0.7)
]
# interface_vertices introduces a global numbering of interfaces.
self.interface_def_points = [
self.__interface12_vertices,
self.__interface23_vertices,
self.__interface34_vertices,
]
def __adjacent_subdomains(self):
"""Set self._adjacent_subdomains."""
self.adjacent_subdomains = [
[1, 2],
[2, 3],
[3, 4],
]
def __subdomain_def_points(self):
"""Set self._subdomain_def_points."""
self.__subdomain1_vertices = [
self.__interface12_vertices[0],
self.__interface12_vertices[1],
self.__interface12_vertices[2],
self.__interface12_vertices[3],
self.__interface12_vertices[4],
self.__subdomain0_vertices[2],
self.__subdomain0_vertices[3]]
self.__subdomain2_vertices = [
self.__interface23_vertices[0],
self.__interface23_vertices[1],
self.__subdomain1_vertices[4],
self.__subdomain1_vertices[3],
self.__subdomain1_vertices[2],
self.__subdomain1_vertices[1],
self.__subdomain1_vertices[0]]
self.__subdomain3_vertices = [
self.__interface34_vertices[0],
self.__interface34_vertices[1],
self.__interface34_vertices[2],
self.__interface34_vertices[3],
self.__interface34_vertices[4],
self.__subdomain2_vertices[1],
self.__subdomain2_vertices[0]
]
# subdomain3
self.__subdomain4_vertices = [
self.__subdomain0_vertices[0],
self.__subdomain0_vertices[1],
self.__subdomain3_vertices[4],
self.__subdomain3_vertices[3],
self.__subdomain3_vertices[2],
self.__subdomain3_vertices[1],
self.__subdomain3_vertices[0]
]
self.subdomain_def_points = [
self.__subdomain0_vertices,
self.__subdomain1_vertices,
self.__subdomain2_vertices,
self.__subdomain3_vertices,
self.__subdomain4_vertices,
]
def __outer_boundary_def_points(self):
"""Set self._outer_boundary_def_points."""
# 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
self.__subdomain1_outer_boundary_verts = {
0: [self.__interface12_vertices[4],
self.__subdomain0_vertices[2],
self.__subdomain0_vertices[3],
self.__interface12_vertices[0]]
}
self.__subdomain2_outer_boundary_verts = {
0: [self.__interface23_vertices[1],
self.__subdomain1_vertices[4]],
1: [self.__subdomain1_vertices[0],
self.__interface23_vertices[0]]
}
self.__subdomain3_outer_boundary_verts = {
0: [self.__interface34_vertices[4],
self.__subdomain2_vertices[1]],
1: [self.__subdomain2_vertices[0],
self.__interface34_vertices[0]]
}
# if a subdomain has no outer boundary write None instead, i.e.
# i: None
self.__subdomain4_outer_boundary_verts = {
0: [self.__subdomain4_vertices[6],
self.__subdomain4_vertices[0],
self.__subdomain4_vertices[1],
self.__subdomain4_vertices[2]]
}
# if i is the index of the inner subdomain.
self.outer_boundary_def_points = {
# subdomain number
1: self.__subdomain1_outer_boundary_verts,
2: self.__subdomain2_outer_boundary_verts,
3: self.__subdomain3_outer_boundary_verts,
4: self.__subdomain4_outer_boundary_verts,
}
class layeredSoilInnerPatch(domainSubstructuring):
"""layered soil substructuring with inner patch."""
def __init__(self):
"""Layered soil case with inner patch."""
super().__init__()
hlp.print_once("\n Layered Soil with inner Patch:\n")
# global domain
self.__subdomain0_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)
]
self.__interface_def_points()
self.__adjacent_subdomains()
self.__subdomain_def_points()
self.__outer_boundary_def_points()
def __interface_def_points(self):
"""Set self._interface_def_points."""
self.__interface12_vertices = [
df.Point(-1.0, 0.8),
df.Point(0.3, 0.8),
df.Point(0.5, 0.9),
df.Point(0.8, 0.7),
df.Point(1.0, 0.65)
]
# interface23
self.__interface23_vertices = [
df.Point(-1.0, 0.0),
df.Point(-0.35, 0.0),
df.Point(0.0, 0.0)
]
self.__interface24_vertices = [
self.__interface23_vertices[2],
df.Point(0.6, 0.0),
]
self.__interface25_vertices = [
self.__interface24_vertices[1],
df.Point(1.0, 0.0)
]
self.__interface32_vertices = [
self.__interface23_vertices[2],
self.__interface23_vertices[1],
self.__interface23_vertices[0]
]
self.__interface36_vertices = [
df.Point(-1.0, -0.6),
df.Point(-0.6, -0.45)
]
self.__interface46_vertices = [
self.__interface36_vertices[1],
df.Point(0.3, -0.25)
]
self.__interface56_vertices = [
self.__interface46_vertices[1],
df.Point(0.65, -0.6),
df.Point(1.0, -0.7)
]
self.__interface34_vertices = [
self.__interface36_vertices[1],
self.__interface23_vertices[2]
]
# Interface 45 needs to be split, because of the shape. There can be
# triangles with two facets on the interface and this creates a rogue
# dof type error when integrating over that particular interface.
# Accordingly, the lambda_param dictionary has two entries for that
# interface.
self.__interface45_vertices_a = [
self.__interface56_vertices[0],
df.Point(0.7, -0.2),
]
self.__interface45_vertices_b = [
df.Point(0.7, -0.2),
self.__interface25_vertices[0]
]
# interface_vertices introduces a global numbering of interfaces.
self.interface_def_points = [
self.__interface12_vertices,
self.__interface23_vertices,
self.__interface24_vertices,
self.__interface25_vertices,
self.__interface34_vertices,
self.__interface36_vertices,
self.__interface45_vertices_a,
self.__interface45_vertices_b,
self.__interface46_vertices,
self.__interface56_vertices,
]
def __adjacent_subdomains(self):
"""Set self._adjacent_subdomains."""
self.adjacent_subdomains = [
[1, 2],
[2, 3],
[2, 4],
[2, 5],
[3, 4],
[3, 6],
[4, 5],
[4, 5],
[4, 6],
[5, 6]
]
def __subdomain_def_points(self):
"""Set self._subdomain_def_points."""
# subdomain1.
self.__subdomain1_vertices = [
self.__interface12_vertices[0],
self.__interface12_vertices[1],
self.__interface12_vertices[2],
self.__interface12_vertices[3],
self.__interface12_vertices[4],
self.__subdomain0_vertices[2],
self.__subdomain0_vertices[3]]
# subdomain1
self.__subdomain2_vertices = [
self.__interface23_vertices[0],
self.__interface23_vertices[1],
self.__interface23_vertices[2],
self.__interface24_vertices[1],
self.__interface25_vertices[1],
self.__subdomain1_vertices[4],
self.__subdomain1_vertices[3],
self.__subdomain1_vertices[2],
self.__subdomain1_vertices[1],
self.__subdomain1_vertices[0]]
self.__subdomain3_vertices = [
self.__interface36_vertices[0],
self.__interface36_vertices[1],
self.__interface34_vertices[1],
self.__interface32_vertices[1],
self.__interface32_vertices[2]
]
# subdomain3
self.__subdomain4_vertices = [
self.__interface46_vertices[0],
self.__interface46_vertices[1],
self.__interface45_vertices_a[1],
self.__interface24_vertices[1],
self.__interface24_vertices[0],
self.__interface34_vertices[1]
]
self.__subdomain5_vertices = [
self.__interface56_vertices[0],
self.__interface56_vertices[1],
self.__interface56_vertices[2],
self.__interface25_vertices[1],
self.__interface25_vertices[0],
self.__interface45_vertices_b[1],
self.__interface45_vertices_b[0]
]
self.__subdomain6_vertices = [
self.__subdomain0_vertices[0],
self.__subdomain0_vertices[1],
self.__interface56_vertices[2],
self.__interface56_vertices[1],
self.__interface56_vertices[0],
self.__interface36_vertices[1],
self.__interface36_vertices[0]
]
self.subdomain_def_points = [
self.__subdomain0_vertices,
self.__subdomain1_vertices,
self.__subdomain2_vertices,
self.__subdomain3_vertices,
self.__subdomain4_vertices,
self.__subdomain5_vertices,
self.__subdomain6_vertices
]
def __outer_boundary_def_points(self):
"""Set self._outer_boundary_def_points."""
# 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
self.__subdomain1_outer_boundary_verts = {
0: [self.__subdomain1_vertices[4],
self.__subdomain1_vertices[5],
self.__subdomain1_vertices[6],
self.__subdomain1_vertices[0]]
}
self.__subdomain2_outer_boundary_verts = {
0: [self.__subdomain2_vertices[9],
self.__subdomain2_vertices[0]],
1: [self.__subdomain2_vertices[4],
self.__subdomain2_vertices[5]]
}
self.__subdomain3_outer_boundary_verts = {
0: [self.__subdomain3_vertices[4],
self.__subdomain3_vertices[0]]
}
self.__subdomain4_outer_boundary_verts = None
self.__subdomain5_outer_boundary_verts = {
0: [self.__subdomain5_vertices[2],
self.__subdomain5_vertices[3]]
}
self.__subdomain6_outer_boundary_verts = {
0: [self.__subdomain6_vertices[6],
self.__subdomain6_vertices[0],
self.__subdomain6_vertices[1],
self.__subdomain6_vertices[2]]
}
# if a subdomain has no outer boundary write None instead, i.e.
# i: None
# if i is the index of the inner subdomain.
self.outer_boundary_def_points = {
# subdomain number
1: self.__subdomain1_outer_boundary_verts,
2: self.__subdomain2_outer_boundary_verts,
3: self.__subdomain3_outer_boundary_verts,
4: self.__subdomain4_outer_boundary_verts,
5: self.__subdomain5_outer_boundary_verts,
6: self.__subdomain6_outer_boundary_verts
}
class chessBoardInnerPatch(domainSubstructuring):
"""layered soil substructuring with inner patch."""
def __init__(self):
"""Layered soil case with inner patch."""
super().__init__()
hlp.print_once("\n Layered Soil with inner Patch:\n")
# global domain
self.__subdomain0_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)
]
self.__interface_def_points()
self.__adjacent_subdomains()
self.__subdomain_def_points()
self.__outer_boundary_def_points()
def __interface_def_points(self):
"""Set self._interface_def_points."""
self.__interface23_vertices = [
df.Point(0.0, -0.6),
df.Point(0.7, 0.0)]
self.__interface12_vertices = [
self.__interface23_vertices[1],
df.Point(1.0, 0.0)]
self.__interface13_vertices = [
df.Point(0.0, 0.0),
self.__interface23_vertices[1]]
self.__interface15_vertices = [
df.Point(0.0, 0.0),
df.Point(0.0, 1.0)]
self.__interface34_vertices = [
df.Point(0.0, 0.0),
self.__interface23_vertices[0]]
self.__interface24_vertices = [
self.__interface23_vertices[0],
df.Point(0.0, -1.0)]
self.__interface45_vertices = [
df.Point(-1.0, 0.0),
df.Point(0.0, 0.0)]
# interface_vertices introduces a global numbering of interfaces.
self.interface_def_points = [
self.__interface13_vertices,
self.__interface12_vertices,
self.__interface23_vertices,
self.__interface24_vertices,
self.__interface34_vertices,
self.__interface45_vertices,
self.__interface15_vertices,
]
def __adjacent_subdomains(self):
"""Set self._adjacent_subdomains."""
self.adjacent_subdomains = [
[1, 3],
[1, 2],
[2, 3],
[2, 4],
[3, 4],
[4, 5],
[1, 5]
]
def __subdomain_def_points(self):
"""Set self._subdomain_def_points."""
# subdomain1.
self.__subdomain1_vertices = [
self.__interface23_vertices[0],
self.__interface23_vertices[1],
self.__interface12_vertices[1],
self.__subdomain0_vertices[2],
df.Point(0.0, 1.0)]
# subdomain2
self.__subdomain2_vertices = [
self.__interface24_vertices[1],
self.__subdomain0_vertices[1],
self.__interface12_vertices[1],
self.__interface23_vertices[1],
self.__interface23_vertices[0]]
self.__subdomain3_vertices = [
self.__interface23_vertices[0],
self.__interface23_vertices[1],
self.__interface13_vertices[0]]
self.__subdomain4_vertices = [
self.__subdomain0_vertices[0],
self.__interface24_vertices[1],
self.__interface34_vertices[1],
self.__interface34_vertices[0],
self.__interface45_vertices[0]]
self.__subdomain5_vertices = [
self.__interface45_vertices[0],
self.__interface15_vertices[0],
self.__interface15_vertices[1],
self.__subdomain0_vertices[3]]
self.subdomain_def_points = [
self.__subdomain0_vertices,
self.__subdomain1_vertices,
self.__subdomain2_vertices,
self.__subdomain3_vertices,
self.__subdomain4_vertices,
self.__subdomain5_vertices,
]
def __outer_boundary_def_points(self):
"""Set self._outer_boundary_def_points."""
# 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
self.__subdomain1_outer_boundary_verts = {
0: [self.__interface12_vertices[1],
self.__subdomain0_vertices[2],
df.Point(0.0, 1.0)]
}
self.__subdomain2_outer_boundary_verts = {
0: [self.__interface24_vertices[1],
self.__subdomain0_vertices[1],
self.__interface12_vertices[1]]
}
self.__subdomain3_outer_boundary_verts = None
self.__subdomain4_outer_boundary_verts = {
0: [self.__interface45_vertices[0],
self.__subdomain0_vertices[0],
self.__interface24_vertices[1]]
}
self.__subdomain5_outer_boundary_verts = {
0: [self.__interface15_vertices[1],
self.__subdomain0_vertices[3],
self.__interface45_vertices[0]]
}
# if a subdomain has no outer boundary write None instead, i.e.
# i: None
# if i is the index of the inner subdomain.
self.outer_boundary_def_points = {
1: self.__subdomain1_outer_boundary_verts,
2: self.__subdomain2_outer_boundary_verts,
3: self.__subdomain3_outer_boundary_verts,
4: self.__subdomain4_outer_boundary_verts,
5: self.__subdomain5_outer_boundary_verts,
}