def __init__(self,
domain,
v_p,
v_s,
wavelet,
source_tag,
source_vector=[0., 1.],
eps=0.,
delta=0.,
theta=0.,
rho=1.,
dt=None,
u0=None,
v0=None,
absorption_zone=300 * U.m,
absorption_cut=1e-2,
lumping=True):
"""
initialize the TTI wave solver
:param domain: domain of the problem
:type domain: `Domain`
:param v_p: vertical p-velocity field
:type v_p: `escript.Scalar`
:param v_s: vertical s-velocity field
:type v_s: `escript.Scalar`
:param wavelet: wavelet to describe the time evolution of source term
:type wavelet: `Wavelet`
:param source_tag: tag of the source location
:type source_tag: 'str' or 'int'
:param source_vector: source orientation vector
:param eps: first Thompsen parameter
:param delta: second Thompsen parameter
:param theta: tilting (in Rad)
:param rho: density
:param dt: time step size. If not present a suitable time step size is calculated.
:param u0: initial solution. If not present zero is used.
:param v0: initial solution change rate. If not present zero is used.
:param absorption_zone: thickness of absorption zone
:param absorption_cut: boundary value of absorption decay factor
:param lumping: if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion.
"""
cos = escript.cos
sin = escript.sin
DIM = domain.getDim()
if not DIM == 2:
raise ValueError("Only 2D is supported.")
f = createAbsorptionLayerFunction(
escript.Function(domain).getX(), absorption_zone, absorption_cut)
v_p = v_p * f
v_s = v_s * f
if u0 == None:
u0 = escript.Vector(0., escript.Solution(domain))
else:
u0 = escript.interpolate(p0, escript.Solution(domain))
if v0 == None:
v0 = escript.Vector(0., escript.Solution(domain))
else:
v0 = escript.interpolate(v0, escript.Solution(domain))
if dt == None:
dt = min((1. / 5.) * min(escript.inf(domain.getSize() / v_p),
escript.inf(domain.getSize() / v_s)),
wavelet.getTimeScale())
super(TTIWave, self).__init__(dt, u0=u0, v0=v0, t0=0.)
self.__wavelet = wavelet
self.__mypde = lpde.LinearPDESystem(domain)
if lumping:
self.__mypde.getSolverOptions().setSolverMethod(
lpde.SolverOptions.HRZ_LUMPING)
self.__mypde.setSymmetryOn()
self.__mypde.setValue(D=rho * escript.kronecker(DIM),
X=self.__mypde.createCoefficient('X'))
self.__source_tag = source_tag
self.__r = escript.Vector(
0, escript.DiracDeltaFunctions(self.__mypde.getDomain()))
self.__r.setTaggedValue(self.__source_tag, source_vector)
c0_33 = v_p**2 * rho
c0_66 = v_s**2 * rho
c0_11 = (1 + 2 * eps) * c0_33
c0_13 = escript.sqrt(2 * c0_33 * (c0_33 - c0_66) * delta +
(c0_33 - c0_66)**2) - c0_66
self.c11 = c0_11 * cos(theta)**4 - 2 * c0_13 * cos(
theta)**4 + 2 * c0_13 * cos(theta)**2 + c0_33 * sin(
theta)**4 - 4 * c0_66 * cos(theta)**4 + 4 * c0_66 * cos(
theta)**2
self.c13 = -c0_11 * cos(theta)**4 + c0_11 * cos(
theta)**2 + c0_13 * sin(theta)**4 + c0_13 * cos(
theta)**4 - c0_33 * cos(theta)**4 + c0_33 * cos(
theta)**2 + 4 * c0_66 * cos(theta)**4 - 4 * c0_66 * cos(
theta)**2
self.c16 = (-2 * c0_11 * cos(theta)**2 - 4 * c0_13 * sin(theta)**2 +
2 * c0_13 + 2 * c0_33 * sin(theta)**2 - 8 * c0_66 *
sin(theta)**2 + 4 * c0_66) * sin(theta) * cos(theta) / 2
self.c33 = c0_11 * sin(theta)**4 - 2 * c0_13 * cos(
theta)**4 + 2 * c0_13 * cos(theta)**2 + c0_33 * cos(
theta)**4 - 4 * c0_66 * cos(theta)**4 + 4 * c0_66 * cos(
theta)**2
self.c36 = (2 * c0_11 * cos(theta)**2 - 2 * c0_11 +
4 * c0_13 * sin(theta)**2 - 2 * c0_13 +
2 * c0_33 * cos(theta)**2 + 8 * c0_66 * sin(theta)**2 -
4 * c0_66) * sin(theta) * cos(theta) / 2
self.c66 = -c0_11 * cos(theta)**4 + c0_11 * cos(
theta)**2 + 2 * c0_13 * cos(theta)**4 - 2 * c0_13 * cos(
theta)**2 - c0_33 * cos(theta)**4 + c0_33 * cos(
theta)**2 + c0_66 * sin(theta)**4 + 3 * c0_66 * cos(
theta)**4 - 2 * c0_66 * cos(theta)**2
def __init__(self,
domain,
v_p,
wavelet,
source_tag,
source_vector=[1., 0.],
eps=0.,
delta=0.,
azimuth=0.,
dt=None,
p0=None,
v0=None,
absorption_zone=300 * U.m,
absorption_cut=1e-2,
lumping=True):
"""
initialize the HTI wave solver
:param domain: domain of the problem
:type domain: `Doamin`
:param v_p: vertical p-velocity field
:type v_p: `escript.Scalar`
:param v_s: vertical s-velocity field
:type v_s: `escript.Scalar`
:param wavelet: wavelet to describe the time evolution of source term
:type wavelet: `Wavelet`
:param source_tag: tag of the source location
:type source_tag: 'str' or 'int'
:param source_vector: source orientation vector
:param eps: first Thompsen parameter
:param azimuth: azimuth (rotation around verticle axis)
:param gamma: third Thompsen parameter
:param rho: density
:param dt: time step size. If not present a suitable time step size is calculated.
:param p0: initial solution (Q(t=0), P(t=0)). If not present zero is used.
:param v0: initial solution change rate. If not present zero is used.
:param absorption_zone: thickness of absorption zone
:param absorption_cut: boundary value of absorption decay factor
:param lumping: if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion.
"""
DIM = domain.getDim()
f = createAbsorptionLayerFunction(v_p.getFunctionSpace().getX(),
absorption_zone, absorption_cut)
self.v2_p = v_p**2
self.v2_t = self.v2_p * escript.sqrt(1 + 2 * delta)
self.v2_n = self.v2_p * (1 + 2 * eps)
if p0 == None:
p0 = escript.Data(0., (2, ), escript.Solution(domain))
else:
p0 = escript.interpolate(p0, escript.Solution(domain))
if v0 == None:
v0 = escript.Data(0., (2, ), escript.Solution(domain))
else:
v0 = escript.interpolate(v0, escript.Solution(domain))
if dt == None:
dt = min(
min(escript.inf(domain.getSize() / escript.sqrt(self.v2_p)),
escript.inf(domain.getSize() / escript.sqrt(self.v2_t)),
escript.inf(domain.getSize() / escript.sqrt(self.v2_n))),
wavelet.getTimeScale()) * 0.2
super(SonicHTIWave, self).__init__(dt, u0=p0, v0=v0, t0=0.)
self.__wavelet = wavelet
self.__mypde = lpde.LinearPDESystem(domain)
if lumping:
self.__mypde.getSolverOptions().setSolverMethod(
lpde.SolverOptions.HRZ_LUMPING)
self.__mypde.setSymmetryOn()
self.__mypde.setValue(D=escript.kronecker(2),
X=self.__mypde.createCoefficient('X'))
self.__source_tag = source_tag
self.__r = escript.Vector(
0, escript.DiracDeltaFunctions(self.__mypde.getDomain()))
self.__r.setTaggedValue(self.__source_tag, source_vector)
def __init__(self,
domain,
v_p,
v_s,
wavelet,
source_tag,
source_vector=[1., 0., 0.],
eps=0.,
gamma=0.,
delta=0.,
rho=1.,
dt=None,
u0=None,
v0=None,
absorption_zone=None,
absorption_cut=1e-2,
lumping=True,
disable_fast_assemblers=False):
"""
initialize the VTI wave solver
:param domain: domain of the problem
:type domain: `Domain`
:param v_p: vertical p-velocity field
:type v_p: `escript.Scalar`
:param v_s: vertical s-velocity field
:type v_s: `escript.Scalar`
:param wavelet: wavelet to describe the time evolution of source term
:type wavelet: `Wavelet`
:param source_tag: tag of the source location
:type source_tag: 'str' or 'int'
:param source_vector: source orientation vector
:param eps: first Thompsen parameter
:param delta: second Thompsen parameter
:param gamma: third Thompsen parameter
:param rho: density
:param dt: time step size. If not present a suitable time step size is calculated.
:param u0: initial solution. If not present zero is used.
:param v0: initial solution change rate. If not present zero is used.
:param absorption_zone: thickness of absorption zone
:param absorption_cut: boundary value of absorption decay factor
:param lumping: if True mass matrix lumping is being used. This is accelerates the computing but introduces some diffusion.
:param disable_fast_assemblers: if True, forces use of slower and more general PDE assemblers
"""
DIM = domain.getDim()
self.fastAssembler = hasattr(
domain, "createAssembler") and not disable_fast_assemblers
f = createAbsorptionLayerFunction(v_p.getFunctionSpace().getX(),
absorption_zone, absorption_cut)
v_p = v_p * f
v_s = v_s * f
if u0 == None:
u0 = escript.Vector(0., escript.Solution(domain))
else:
u0 = escript.interpolate(p0, escript.Solution(domain))
if v0 == None:
v0 = escript.Vector(0., escript.Solution(domain))
else:
v0 = escript.interpolate(v0, escript.Solution(domain))
if dt == None:
dt = min((1. / 5.) * min(escript.inf(domain.getSize() / v_p),
escript.inf(domain.getSize() / v_s)),
wavelet.getTimeScale())
super(HTIWave, self).__init__(dt, u0=u0, v0=v0, t0=0.)
self.__wavelet = wavelet
self.c33 = v_p**2 * rho
self.c44 = v_s**2 * rho
self.c11 = (1 + 2 * eps) * self.c33
self.c66 = (1 + 2 * gamma) * self.c44
self.c13 = escript.sqrt(2 * self.c33 * (self.c33 - self.c44) * delta +
(self.c33 - self.c44)**2) - self.c44
self.c23 = self.c33 - 2 * self.c66
if self.fastAssembler:
C = [("c11", self.c11), ("c23", self.c23), ("c13", self.c13),
("c33", self.c33), ("c44", self.c44), ("c66", self.c66)]
if "speckley" in domain.getDescription().lower():
C = [(n, escript.interpolate(d,
escript.ReducedFunction(domain)))
for n, d in C]
self.__mypde = lpde.WavePDE(domain, C)
else:
self.__mypde = lpde.LinearPDESystem(domain)
self.__mypde.setValue(X=self.__mypde.createCoefficient('X'))
if lumping:
self.__mypde.getSolverOptions().setSolverMethod(
lpde.SolverOptions.HRZ_LUMPING)
self.__mypde.setSymmetryOn()
self.__mypde.setValue(D=rho * escript.kronecker(DIM))
self.__source_tag = source_tag
if DIM == 2:
source_vector = [source_vector[0], source_vector[2]]
self.__r = escript.Vector(
0, escript.DiracDeltaFunctions(self.__mypde.getDomain()))
self.__r.setTaggedValue(self.__source_tag, source_vector)