def _rebuild_operators(self):
dof = self.mesh.dof(include_bc=True)
# a more readable reference
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh, 2,
self.spatial_accuracy_order)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.minus_sigmax = make_diag_mtx(-sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.minus_sigmaz = make_diag_mtx(-sz)
# build Dx
oc.Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x')
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx * sz)
oc.minus_sigma_xPz = oc.minus_sigmax + oc.minus_sigmaz
oc.sigma_zMx_Dx = make_diag_mtx(sz - sx) * oc.Dx
oc.sigma_xMz_Dz = make_diag_mtx(sx - sz) * oc.Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m_inv = make_diag_mtx((C**2).reshape(-1, ))
self.A = spsp.bmat(
[[oc.empty, oc.I, oc.empty, oc.empty],
[
oc.m_inv * oc.L - oc.sigma_xz, oc.minus_sigma_xPz,
oc.m_inv * oc.Dx, oc.m_inv * oc.Dz
], [oc.sigma_zMx_Dx, oc.empty, oc.minus_sigmax, oc.empty],
[oc.sigma_xMz_Dz, oc.empty, oc.empty, oc.minus_sigmaz]])
def _rebuild_operators(self):
dof = self.mesh.dof(include_bc=True)
# a more readable reference
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.minus_sigmax = make_diag_mtx(-sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.minus_sigmaz = make_diag_mtx(-sz)
# build Dx
oc.Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x')
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx*sz)
oc.minus_sigma_xPz = oc.minus_sigmax + oc.minus_sigmaz
oc.sigma_zMx_Dx = make_diag_mtx(sz-sx)*oc.Dx
oc.sigma_xMz_Dz = make_diag_mtx(sx-sz)*oc.Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m_inv = make_diag_mtx((C**2).reshape(-1,))
self.A = spsp.bmat([[oc.empty, oc.I, oc.empty, oc.empty ],
[oc.m_inv*oc.L-oc.sigma_xz, oc.minus_sigma_xPz, oc.m_inv*oc.Dx, oc.m_inv*oc.Dz ],
[oc.sigma_zMx_Dx, oc.empty, oc.minus_sigmax, oc.empty ],
[oc.sigma_xMz_Dz, oc.empty, oc.empty, oc.minus_sigmaz ]])
def _rebuild_operators(self):
ConstantDensityAcousticTimeScalar_1D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# Stiffness matrix K doesn't change
oc.K = spsp.bmat([[ -oc.L, -oc.Dz],
[oc.sigmaz*oc.Dz, oc.sigmaz]])
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1,))
C = spsp.bmat([[oc.sigmaz*oc.m, None],
[ None, oc.I]]) / self.dt
M = spsp.bmat([[oc.m, None],
[None, oc.empty]]) / self.dt**2
Stilde_inv = M+C
Stilde_inv.data = 1./Stilde_inv.data
self.A_k = Stilde_inv*(2*M - oc.K + C)
self.A_km1 = -1*Stilde_inv*(M)
self.A_f = Stilde_inv
def _rebuild_operators(self):
ConstantDensityAcousticTimeScalar_1D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# Stiffness matrix K doesn't change
oc.K = spsp.bmat([[-oc.L, -oc.Dz],
[oc.sigmaz*oc.Dz, oc.sigmaz]])
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1,))
C = spsp.bmat([[oc.sigmaz*oc.m, None],
[None, oc.I]]) / self.dt
M = spsp.bmat([[oc.m, None],
[None, oc.empty]]) / self.dt**2
Stilde_inv = M+C
Stilde_inv.data = 1./Stilde_inv.data
self.A_k = Stilde_inv*(2*M - oc.K + C)
self.A_km1 = -1*Stilde_inv*(M)
self.A_f = Stilde_inv
def _rebuild_operators(self):
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
oc.I = spsp.eye(dof, dof)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
use_shifted_differences=self.spatial_shifted_differences)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build other useful things
oc.empty = spsp.csr_matrix((dof, dof))
# Stiffness matrix K doesn't change
self.K = spsp.bmat([[-oc.L, -oc.Dz],
[oc.sigmaz*oc.Dz, oc.sigmaz]])
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1,))
self.C = spsp.bmat([[oc.sigmaz*oc.m, None],
[None, oc.I]])
self.M = spsp.bmat([[oc.m, None],
[None, oc.empty]])
self.dM = oc.I
self.dC = oc.sigmaz
self.dK = 0
def _rebuild_operators(self):
ConstantDensityAcousticTimeScalar_2D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
nx = self.mesh.x.n
nz = self.mesh.z.n
#We actually don't need to correct the operators for the boundary nodes. But it will make the final matrix a little more sparse and therefore faster. Also, it makes is more clear that something needs to happen to the boundary. Any failure to do so can easily be seen by eye.
self.left_boundary_nodes = np.arange(
0, nz) #includes left corner dirichlet nodes
self.right_boundary_nodes = np.arange(
(nx - 1) * nz, nx * nz) #uncludes right corner dirichlet nodes
self.top_boundary_nodes = np.arange(
nz, (nx - 1) * nz,
nx) #does not include corner dirichlet nodes
self.bot_boundary_nodes = np.arange(
2 * nz - 1, nx * nz - 1,
nx) #does not include corner dirichlet nodes
self.all_boundary_nodes = np.concatenate([
self.left_boundary_nodes, self.right_boundary_nodes,
self.top_boundary_nodes, self.bot_boundary_nodes
])
# build laplacian
oc.L = build_derivative_matrix(self.mesh, 2,
self.spatial_accuracy_order)
#Set the rows corresponding to the boundary nodes in oc.L to zero (could be any junk value). This is not necessary, but will indicate that I will have to correct the boundary values at the end of the time increment.
oc.L = self._zero_mat_rows(oc.L, self.all_boundary_nodes)
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
oc._numpy_components_built = True
C = self.model_parameters.C #just wavespeed. Don't confuse with the matrix C that used to be here for a while
oc.m = make_diag_mtx((C**-2).reshape(-1, ))
K = -oc.L
M = oc.m / self.dt**2
M_bc_zero = self._zero_mat_rows(
M, self.all_boundary_nodes
) #put boundary values to zero, not really necessary because boundary values will be overwritten anyway. But easier to see that something must happen when the algorithm will default them to zero so you know you need to correct them.
Stilde_inv = M
Stilde_inv.data = 1. / Stilde_inv.data
self.A_k = Stilde_inv * (2 * M_bc_zero - K)
self.A_km1 = -1 * Stilde_inv * (M_bc_zero)
self.A_f = Stilde_inv
def _rebuild_operators(self):
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order)
# build sigmaz (stored as -1*sigmaz)
sz = build_sigma(self.mesh, self.mesh.z)
oc.minus_sigmaz = make_diag_mtx(-sz)
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m_inv = make_diag_mtx((C**2).reshape(-1,))
self.A = spsp.bmat([[oc.empty, oc.I, oc.empty ],
[oc.m_inv*oc.L, oc.minus_sigmaz, oc.m_inv*oc.Dz ],
[oc.minus_sigmaz*oc.Dz, oc.empty, oc.minus_sigmaz]])
def _rebuild_operators(self):
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order)
# build sigmaz (stored as -1*sigmaz)
sz = build_sigma(self.mesh, self.mesh.z)
oc.minus_sigmaz = make_diag_mtx(-sz)
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m_inv = make_diag_mtx((C**2).reshape(-1,))
self.A = spsp.bmat([[oc.empty, oc.I, oc.empty ],
[oc.m_inv*oc.L, oc.minus_sigmaz, oc.m_inv*oc.Dz ],
[oc.minus_sigmaz*oc.Dz, oc.empty, oc.minus_sigmaz]])
def _rebuild_operators(self):
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
use_shifted_differences=self.spatial_shifted_differences)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmay
sy = build_sigma(self.mesh, self.mesh.y)
oc.sigmay = make_diag_mtx(sy)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dy
oc.minus_Dy = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='y',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dy.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.minus_I = -1*oc.I
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_sum_pair_prod = make_diag_mtx(sx*sy + sx*sz + sy*sz)
oc.sigma_sum = make_diag_mtx(sx+sy+sz)
oc.sigma_prod = make_diag_mtx(sx*sy*sz)
oc.minus_sigma_yPzMx_Dx = make_diag_mtx(sy+sz-sx)*oc.minus_Dx
oc.minus_sigma_xPzMy_Dy = make_diag_mtx(sx+sz-sy)*oc.minus_Dy
oc.minus_sigma_xPyMz_Dz = make_diag_mtx(sx+sy-sz)*oc.minus_Dz
oc.minus_sigma_yz_Dx = make_diag_mtx(sy*sz)*oc.minus_Dx
oc.minus_sigma_zx_Dy = make_diag_mtx(sz*sx)*oc.minus_Dy
oc.minus_sigma_xy_Dz = make_diag_mtx(sx*sy)*oc.minus_Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1,))
self.K = spsp.bmat([[oc.m*oc.sigma_sum_pair_prod-oc.L, oc.m*oc.sigma_prod, oc.minus_Dx, oc.minus_Dy, oc.minus_Dz ],
[oc.minus_I, oc.empty, oc.empty, oc.empty, oc.empty ],
[oc.minus_sigma_yPzMx_Dx, oc.minus_sigma_yz_Dx, oc.sigmax, oc.empty, oc.empty ],
[oc.minus_sigma_xPzMy_Dy, oc.minus_sigma_zx_Dy, oc.empty, oc.sigmay, oc.empty ],
[oc.minus_sigma_xPyMz_Dz, oc.minus_sigma_xy_Dz, oc.empty, oc.empty, oc.sigmaz ]])
self.C = spsp.bmat([[oc.m*oc.sigma_sum, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.I, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.I ]]) / self.dt
self.M = spsp.bmat([[ oc.m, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty]])
def _rebuild_operators(self):
ConstantDensityAcousticTimeScalar_2D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x')
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx*sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz-sx))*oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx-sz))*oc.minus_Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1,))
K = spsp.bmat([[oc.m*oc.sigma_xz-oc.L, oc.minus_Dx, oc.minus_Dz],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz]])
C = spsp.bmat([[oc.m*oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I]]) / self.dt
M = spsp.bmat([[oc.m, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]]) / self.dt**2
Stilde_inv = M+C
Stilde_inv.data = 1./Stilde_inv.data
self.A_k = Stilde_inv*(2*M - K + C)
self.A_km1 = -1*Stilde_inv*(M)
self.A_f = Stilde_inv
def _rebuild_operators(self):
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
use_shifted_differences=self.spatial_shifted_differences)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx*sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz-sx))*oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx-sz))*oc.minus_Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1,))
self.K = spsp.bmat([[oc.m*oc.sigma_xz-oc.L, oc.minus_Dx, oc.minus_Dz ],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty ],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz ]])
self.C = spsp.bmat([[oc.m*oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I ]])
self.M = spsp.bmat([[ oc.m, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]])
def _rebuild_operators(self):
ConstantDensityAcousticTimeScalar_3D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get("_numpy_components_built", False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh, 2, self.spatial_accuracy_order)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmay
sy = build_sigma(self.mesh, self.mesh.y)
oc.sigmay = make_diag_mtx(sy)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh, 1, self.spatial_accuracy_order, dimension="x")
oc.minus_Dx.data *= -1
# build Dy
oc.minus_Dy = build_derivative_matrix(self.mesh, 1, self.spatial_accuracy_order, dimension="y")
oc.minus_Dy.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh, 1, self.spatial_accuracy_order, dimension="z")
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.minus_I = -1 * oc.I
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_sum_pair_prod = make_diag_mtx(sx * sy + sx * sz + sy * sz)
oc.sigma_sum = make_diag_mtx(sx + sy + sz)
oc.sigma_prod = make_diag_mtx(sx * sy * sz)
oc.minus_sigma_yPzMx_Dx = make_diag_mtx(sy + sz - sx) * oc.minus_Dx
oc.minus_sigma_xPzMy_Dy = make_diag_mtx(sx + sz - sy) * oc.minus_Dy
oc.minus_sigma_xPyMz_Dz = make_diag_mtx(sx + sy - sz) * oc.minus_Dz
oc.minus_sigma_yz_Dx = make_diag_mtx(sy * sz) * oc.minus_Dx
oc.minus_sigma_zx_Dy = make_diag_mtx(sz * sx) * oc.minus_Dy
oc.minus_sigma_xy_Dz = make_diag_mtx(sx * sy) * oc.minus_Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C ** -2).reshape(-1))
K = spsp.bmat(
[
[oc.m * oc.sigma_sum_pair_prod - oc.L, oc.m * oc.sigma_prod, oc.minus_Dx, oc.minus_Dy, oc.minus_Dz],
[oc.minus_I, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.minus_sigma_yPzMx_Dx, oc.minus_sigma_yz_Dx, oc.sigmax, oc.empty, oc.empty],
[oc.minus_sigma_xPzMy_Dy, oc.minus_sigma_zx_Dy, oc.empty, oc.sigmay, oc.empty],
[oc.minus_sigma_xPyMz_Dz, oc.minus_sigma_xy_Dz, oc.empty, oc.empty, oc.sigmaz],
]
)
C = (
spsp.bmat(
[
[oc.m * oc.sigma_sum, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.I, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.I],
]
)
/ self.dt
)
M = (
spsp.bmat(
[
[oc.m, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
]
)
/ self.dt ** 2
)
Stilde_inv = M + C
Stilde_inv.data = 1.0 / Stilde_inv.data
self.A_k = Stilde_inv * (2 * M - K + C)
self.A_km1 = -1 * Stilde_inv * (M)
self.A_f = Stilde_inv
def _rebuild_operators(self):
if self.mesh.x.lbc.type == 'pml' and self.compact:
# build intermediates for the compact operator
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
oc.M = make_diag_mtx(self.model_parameters.C.squeeze()**-2)
oc.I = spsp.eye(dof, dof)
# build the static components
if not built:
# build Dxx
oc.Dxx = build_derivative_matrix(
self.mesh,
2,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dzz
oc.Dzz = build_derivative_matrix(
self.mesh,
2,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build Dx
oc.Dx = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dz
oc.Dz = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build sigma
oc.sx, oc.sz, oc.sxp, oc.szp = self._sigma_PML(self.mesh)
oc._numpy_components_built = True
self.dK = 0
self.dC = 0
self.dM = oc.I
else:
# build intermediates for operator with auxiliary fields
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
oc.I = spsp.eye(dof, dof)
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(
self.mesh,
2,
self.spatial_accuracy_order,
use_shifted_differences=self.spatial_shifted_differences)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx * sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz - sx)) * oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx - sz)) * oc.minus_Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1, ))
self.K = spsp.bmat(
[[oc.m * oc.sigma_xz - oc.L, oc.minus_Dx, oc.minus_Dz],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz]])
self.C = spsp.bmat([[oc.m * oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I]])
self.M = spsp.bmat([[oc.m, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]])
self.dK = oc.sigma_xz
self.dC = oc.sigma_xPz
self.dM = oc.I
def _rebuild_operators(self):
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx*sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz-sx))*oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx-sz))*oc.minus_Dz
oc._numpy_components_built = True
kappa = self.model_parameters.kappa
rho = self.model_parameters.rho
oc.m1 = make_diag_mtx((kappa**-1).reshape(-1,))
oc.m2 = make_diag_mtx((rho**-1).reshape(-1,))
# build heterogenous laplacian
sh = self.mesh.shape(include_bc=True,as_grid=True)
deltas = [self.mesh.x.delta,self.mesh.z.delta]
oc.L = build_heterogenous_laplacian(sh,rho**-1,deltas)
# oc.L is a heterogenous laplacian operator. It computes div(m2 grad), where m2 = 1/rho.
# Currently the creation of oc.L is slow. This is because we have implemented a cenetered heterogenous laplacian.
# To speed up computation, we could compute a div(m2 grad) operator that is not centered by simply multiplying
# a divergence operator by oc.m2 by a gradient operator.
self.K = spsp.bmat([[oc.m1*oc.sigma_xz-oc.L, oc.minus_Dx*oc.m2, oc.minus_Dz*oc.m2 ],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty ],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz ]])
self.C = spsp.bmat([[oc.m1*oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I ]])
self.M = spsp.bmat([[ oc.m1, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]])
def _rebuild_operators(self):
if self.mesh.x.lbc.type == 'pml' and self.compact:
# build intermediates for the compact operator
raise ValidationFunctionError(" This solver is in construction and is not yet complete. For variable density and compact PML.")
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
oc.M = make_diag_mtx(self.model_parameters.C.squeeze()**-2)
# build the static components
if not built:
# build Dxx
oc.Dxx = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dzz
oc.Dzz = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build Dx
oc.Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build sigma
oc.sx, oc.sz, oc.sxp, oc.szp = self._sigma_PML(self.mesh)
oc._numpy_components_built = True
else:
# build intermediates for operator with auxiliary fields
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx*sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz-sx))*oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx-sz))*oc.minus_Dz
oc._numpy_components_built = True
kappa = self.model_parameters.kappa
rho = self.model_parameters.rho
oc.m1 = make_diag_mtx((kappa**-1).reshape(-1,))
oc.m2 = make_diag_mtx((rho**-1).reshape(-1,))
# build heterogenous laplacian
sh = self.mesh.shape(include_bc=True,as_grid=True)
deltas = [self.mesh.x.delta,self.mesh.z.delta]
oc.L = build_heterogenous_laplacian(sh,rho**-1,deltas)
# oc.L is a heterogenous laplacian operator. It computes div(m2 grad), where m2 = 1/rho.
# Currently the creation of oc.L is slow. This is because we have implemented a cenetered heterogenous laplacian.
# To speed up computation, we could compute a div(m2 grad) operator that is not centered by simply multiplying
# a divergence operator by oc.m2 by a gradient operator.
self.K = spsp.bmat([[oc.m1*oc.sigma_xz-oc.L, oc.minus_Dx*oc.m2, oc.minus_Dz*oc.m2 ],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty ],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz ]])
self.C = spsp.bmat([[oc.m1*oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I ]])
self.M = spsp.bmat([[ oc.m1, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]])
def _rebuild_operators(self):
VariableDensityAcousticTimeScalar_2D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x')
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx*sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz-sx))*oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx-sz))*oc.minus_Dz
oc._numpy_components_built = True
kappa = self.model_parameters.kappa
rho = self.model_parameters.rho
oc.m1 = make_diag_mtx((kappa**-1).reshape(-1,))
oc.m2 = make_diag_mtx((rho**-1).reshape(-1,))
# build heterogenous laplacian
sh = self.mesh.shape(include_bc=True,as_grid=True)
deltas = [self.mesh.x.delta,self.mesh.z.delta]
oc.L = build_heterogenous_laplacian(sh,rho**-1,deltas)
# oc.L is a heterogenous laplacian operator. It computes div(m2 grad), where m2 = 1/rho.
# Currently the creation of oc.L is slow. This is because we have implemented a cenetered heterogenous laplacian.
# To speed up computation, we could compute a div(m2 grad) operator that is not centered by simply multiplying
# a divergence operator by oc.m2 by a gradient operator.
K = spsp.bmat([[oc.m1*oc.sigma_xz-oc.L, oc.minus_Dx*oc.m2, oc.minus_Dz*oc.m2 ],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty ],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz ]])
C = spsp.bmat([[oc.m1*oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I ]]) / self.dt
M = spsp.bmat([[ oc.m1, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]]) / self.dt**2
Stilde_inv = M+C
Stilde_inv.data = 1./Stilde_inv.data
self.A_k = Stilde_inv*(2*M - K + C)
self.A_km1 = -1*Stilde_inv*(M)
self.A_f = Stilde_inv
def _rebuild_operators(self):
VariableDensityAcousticTimeScalar_2D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x')
oc.minus_Dx = copy.deepcopy(oc.Dx) #more storage, but less computations
oc.minus_Dx.data *= -1
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
oc.minus_Dz = copy.deepcopy(oc.Dz) #more storage, but less computations
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx*sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz-sx))*oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx-sz))*oc.minus_Dz
oc._numpy_components_built = True
kappa = self.model_parameters.kappa
rho = self.model_parameters.rho
oc.m1 = make_diag_mtx((kappa**-1).reshape(-1,))
oc.m2 = make_diag_mtx((rho**-1).reshape(-1,))
oc.L = build_derivative_matrix_VDA(self.mesh,
2,
self.spatial_accuracy_order,
alpha = rho**-1
)
# oc.L is a heterogenous laplacian operator. It computes div(m2 grad), where m2 = 1/rho.
# Ian's implementation used the regular Dx operators in the PML even though the heterogeneous Laplacian with staggered derivative operators is used in the physical domain.
# I (Bram) did not change this or investigate if this causes some problems but am noting it here for completeness.
K = spsp.bmat([[oc.m1*oc.sigma_xz-oc.L, oc.minus_Dx*oc.m2, oc.minus_Dz*oc.m2 ],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty ],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz ]])
C = spsp.bmat([[oc.m1*oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I ]]) / self.dt
M = spsp.bmat([[ oc.m1, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]]) / self.dt**2
Stilde_inv = M+C
Stilde_inv.data = 1./Stilde_inv.data
self.A_k = Stilde_inv*(2*M - K + C)
self.A_km1 = -1*Stilde_inv*(M)
self.A_f = Stilde_inv
def _rebuild_operators(self):
VariableDensityAcousticTimeScalar_2D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x')
oc.minus_Dx = copy.deepcopy(
oc.Dx) #more storage, but less computations
oc.minus_Dx.data *= -1
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
oc.minus_Dz = copy.deepcopy(
oc.Dz) #more storage, but less computations
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx * sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz - sx)) * oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx - sz)) * oc.minus_Dz
oc._numpy_components_built = True
kappa = self.model_parameters.kappa
rho = self.model_parameters.rho
oc.m1 = make_diag_mtx((kappa**-1).reshape(-1, ))
oc.m2 = make_diag_mtx((rho**-1).reshape(-1, ))
oc.L = build_derivative_matrix_VDA(self.mesh,
2,
self.spatial_accuracy_order,
alpha=rho**-1)
# oc.L is a heterogenous laplacian operator. It computes div(m2 grad), where m2 = 1/rho.
# Ian's implementation used the regular Dx operators in the PML even though the heterogeneous Laplacian with staggered derivative operators is used in the physical domain.
# I (Bram) did not change this or investigate if this causes some problems but am noting it here for completeness.
K = spsp.bmat([[
oc.m1 * oc.sigma_xz - oc.L, oc.minus_Dx * oc.m2,
oc.minus_Dz * oc.m2
], [oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz]])
C = spsp.bmat([[oc.m1 * oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty], [oc.empty, oc.empty, oc.I]
]) / self.dt
M = spsp.bmat([[oc.m1, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]]) / self.dt**2
Stilde_inv = M + C
Stilde_inv.data = 1. / Stilde_inv.data
self.A_k = Stilde_inv * (2 * M - K + C)
self.A_km1 = -1 * Stilde_inv * (M)
self.A_f = Stilde_inv
def _rebuild_operators(self):
if self.mesh.x.lbc.type == 'pml' and self.compact:
# build intermediates for compact operator
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
oc.M = make_diag_mtx(self.model_parameters.C.squeeze()**-2)
# build the static components
if not built:
# build Dxx
oc.Dxx = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dzz
oc.Dzz = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build Dyy
oc.Dyy = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
dimension='y',
use_shifted_differences=self.spatial_shifted_differences)
# build Dx
oc.Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build Dz
oc.Dy = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='y',
use_shifted_differences=self.spatial_shifted_differences)
# build sigma
oc.sx, oc.sy, oc.sz, oc.sxp, oc.syp, oc.szp = self._sigma_PML(self.mesh)
oc._numpy_components_built = True
else :
# build intermediates for operator with auxiliary fields
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
use_shifted_differences=self.spatial_shifted_differences)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmay
sy = build_sigma(self.mesh, self.mesh.y)
oc.sigmay = make_diag_mtx(sy)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dy
oc.minus_Dy = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='y',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dy.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.minus_I = -1*oc.I
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_sum_pair_prod = make_diag_mtx(sx*sy + sx*sz + sy*sz)
oc.sigma_sum = make_diag_mtx(sx+sy+sz)
oc.sigma_prod = make_diag_mtx(sx*sy*sz)
oc.minus_sigma_yPzMx_Dx = make_diag_mtx(sy+sz-sx)*oc.minus_Dx
oc.minus_sigma_xPzMy_Dy = make_diag_mtx(sx+sz-sy)*oc.minus_Dy
oc.minus_sigma_xPyMz_Dz = make_diag_mtx(sx+sy-sz)*oc.minus_Dz
oc.minus_sigma_yz_Dx = make_diag_mtx(sy*sz)*oc.minus_Dx
oc.minus_sigma_zx_Dy = make_diag_mtx(sz*sx)*oc.minus_Dy
oc.minus_sigma_xy_Dz = make_diag_mtx(sx*sy)*oc.minus_Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1,))
self.K = spsp.bmat([[oc.m*oc.sigma_sum_pair_prod-oc.L, oc.m*oc.sigma_prod, oc.minus_Dx, oc.minus_Dy, oc.minus_Dz ],
[oc.minus_I, oc.empty, oc.empty, oc.empty, oc.empty ],
[oc.minus_sigma_yPzMx_Dx, oc.minus_sigma_yz_Dx, oc.sigmax, oc.empty, oc.empty ],
[oc.minus_sigma_xPzMy_Dy, oc.minus_sigma_zx_Dy, oc.empty, oc.sigmay, oc.empty ],
[oc.minus_sigma_xPyMz_Dz, oc.minus_sigma_xy_Dz, oc.empty, oc.empty, oc.sigmaz ]])
self.C = spsp.bmat([[oc.m*oc.sigma_sum, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.I, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.I ]]) / self.dt
self.M = spsp.bmat([[ oc.m, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty, oc.empty, oc.empty]])
def _rebuild_operators(self):
if self.mesh.x.lbc.type == 'pml' and self.compact:
# build intermediates for the compact operator
raise ValidationFunctionError(
" This solver is in construction and is not yet complete. For variable density and compact PML."
)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
oc.M = make_diag_mtx(self.model_parameters.C.squeeze()**-2)
# build the static components
if not built:
# build Dxx
oc.Dxx = build_derivative_matrix(
self.mesh,
2,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dzz
oc.Dzz = build_derivative_matrix(
self.mesh,
2,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build Dx
oc.Dx = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dz
oc.Dz = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build sigma
oc.sx, oc.sz, oc.sxp, oc.szp = self._sigma_PML(self.mesh)
oc._numpy_components_built = True
else:
# build intermediates for operator with auxiliary fields
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx * sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz - sx)) * oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx - sz)) * oc.minus_Dz
oc._numpy_components_built = True
kappa = self.model_parameters.kappa
rho = self.model_parameters.rho
oc.m1 = make_diag_mtx((kappa**-1).reshape(-1, ))
oc.m2 = make_diag_mtx((rho**-1).reshape(-1, ))
# build heterogenous laplacian
sh = self.mesh.shape(include_bc=True, as_grid=True)
deltas = [self.mesh.x.delta, self.mesh.z.delta]
oc.L = build_derivative_matrix_VDA(self.mesh,
2,
self.spatial_accuracy_order,
alpha=rho**-1)
# oc.L is a heterogenous laplacian operator. It computes div(m2 grad), where m2 = 1/rho.
# Currently the creation of oc.L is slow. This is because we have implemented a cenetered heterogenous laplacian.
# To speed up computation, we could compute a div(m2 grad) operator that is not centered by simply multiplying
# a divergence operator by oc.m2 by a gradient operator.
self.K = spsp.bmat([[
oc.m1 * oc.sigma_xz - oc.L, oc.minus_Dx * oc.m2,
oc.minus_Dz * oc.m2
], [oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz]])
self.C = spsp.bmat([[oc.m1 * oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I]])
self.M = spsp.bmat([[oc.m1, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]])
def _rebuild_operators(self):
ConstantDensityAcousticTimeScalar_2D._rebuild_operators(self)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh, 2,
self.spatial_accuracy_order)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x')
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z')
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx * sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz - sx)) * oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx - sz)) * oc.minus_Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1, ))
K = spsp.bmat([[oc.m * oc.sigma_xz - oc.L, oc.minus_Dx, oc.minus_Dz],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz]])
C = spsp.bmat([[oc.m * oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty], [oc.empty, oc.empty, oc.I]
]) / self.dt
M = spsp.bmat([[oc.m, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]]) / self.dt**2
Stilde_inv = M + C
Stilde_inv.data = 1. / Stilde_inv.data
self.A_k = Stilde_inv * (2 * M - K + C)
self.A_km1 = -1 * Stilde_inv * (M)
self.A_f = Stilde_inv
def _rebuild_operators(self):
if self.mesh.x.lbc.type == 'pml' and self.compact:
# build intermediates for the compact operator
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
oc.M = make_diag_mtx(self.model_parameters.C.squeeze()**-2)
oc.I = spsp.eye(dof, dof)
# build the static components
if not built:
# build Dxx
oc.Dxx = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dzz
oc.Dzz = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build Dx
oc.Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dz
oc.Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build sigma
oc.sx, oc.sz, oc.sxp, oc.szp = self._sigma_PML(self.mesh)
oc._numpy_components_built = True
self.dK = 0
self.dC = 0
self.dM = oc.I
else:
# build intermediates for operator with auxiliary fields
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
oc.I = spsp.eye(dof, dof)
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build laplacian
oc.L = build_derivative_matrix(self.mesh,
2,
self.spatial_accuracy_order,
use_shifted_differences=self.spatial_shifted_differences)
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx*sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz-sx))*oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx-sz))*oc.minus_Dz
oc._numpy_components_built = True
C = self.model_parameters.C
oc.m = make_diag_mtx((C**-2).reshape(-1,))
self.K = spsp.bmat([[oc.m*oc.sigma_xz-oc.L, oc.minus_Dx, oc.minus_Dz],
[oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz]])
self.C = spsp.bmat([[oc.m*oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I]])
self.M = spsp.bmat([[oc.m, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]])
self.dK = oc.sigma_xz
self.dC = oc.sigma_xPz
self.dM = oc.I
