def test_mappings_and_cell_weights(self):
mesh = discretize.TensorMesh([8, 7, 6])
m = np.random.rand(2 * mesh.nC)
v = np.random.rand(2 * mesh.nC)
cell_weights = np.random.rand(mesh.nC)
wires = maps.Wires(("sigma", mesh.nC), ("mu", mesh.nC))
reg = regularization.SimpleSmall(mesh,
mapping=wires.sigma,
cell_weights=cell_weights)
objfct = objective_function.L2ObjectiveFunction(W=utils.sdiag(
np.sqrt(cell_weights)),
mapping=wires.sigma)
self.assertTrue(reg(m) == objfct(m))
self.assertTrue(np.all(reg.deriv(m) == objfct.deriv(m)))
self.assertTrue(np.all(reg.deriv2(m, v=v) == objfct.deriv2(m, v=v)))
def test_sum(self):
M2 = discretize.TensorMesh([np.ones(10), np.ones(20)], "CC")
block = maps.ParametricEllipsoid(M2) * maps.Projection(
7, np.r_[1, 2, 3, 4, 5, 6])
background = (maps.ExpMap(M2) * maps.SurjectFull(M2) *
maps.Projection(7, np.r_[0]))
summap0 = maps.SumMap([block, background])
summap1 = block + background
m0 = np.hstack([
np.random.rand(3),
np.r_[M2.x0[0], 2 * M2.hx.min()],
np.r_[M2.x0[1], 4 * M2.hy.min()],
])
self.assertTrue(np.all(summap0 * m0 == summap1 * m0))
self.assertTrue(summap0.test(m0))
self.assertTrue(summap1.test(m0))
def setup1DSurvey(sigmaHalf, tD=False, structure=False):
# Frequency
nFreq = 33
freqs = np.logspace(3, -3, nFreq)
# Make the mesh
ct = 5
air = meshTensor([(ct, 25, 1.3)])
# coreT0 = meshTensor([(ct,15,1.2)])
# coreT1 = np.kron(meshTensor([(coreT0[-1],15,1.3)]),np.ones((7,)))
core = np.concatenate((np.kron(meshTensor([(ct, 15, -1.2)]), np.ones(
(10, ))), meshTensor([(ct, 20)])))
bot = meshTensor([(core[0], 20, -1.3)])
x0 = -np.array([np.sum(np.concatenate((core, bot)))])
m1d = discretize.TensorMesh([np.concatenate((bot, core, air))], x0=x0)
# Make the model
sigma = np.zeros(m1d.nC) + sigmaHalf
sigma[m1d.gridCC > 0] = 1e-8
sigmaBack = sigma.copy()
# Add structure
if structure:
shallow = (m1d.gridCC < -200) * (m1d.gridCC > -600)
deep = (m1d.gridCC < -3000) * (m1d.gridCC > -5000)
sigma[shallow] = 1
sigma[deep] = 0.1
rxList = []
for rxType in ["z1d", "z1d"]:
rxList.append(Point1DImpedance(mkvc(np.array([0.0]), 2).T, "real"))
rxList.append(Point1DImpedance(mkvc(np.array([0.0]), 2).T, "imag"))
# Source list
srcList = []
if tD:
for freq in freqs:
srcList.append(Planewave_xy_1DhomotD(rxList, freq))
else:
for freq in freqs:
srcList.append(Planewave_xy_1Dprimary(rxList, freq))
survey = Survey(srcList)
return (survey, sigma, sigmaBack, m1d)
def setUp(self):
cs = 12.5
hx = [(cs, 7, -1.3), (cs, 61), (cs, 7, 1.3)]
hy = [(cs, 7, -1.3), (cs, 20)]
mesh = discretize.TensorMesh([hx, hy], x0="CN")
x = np.linspace(-200, 200.0, 20)
M = utils.ndgrid(x - 12.5, np.r_[0.0])
N = utils.ndgrid(x + 12.5, np.r_[0.0])
A0loc = np.r_[-150, 0.0]
A1loc = np.r_[-130, 0.0]
B0loc = np.r_[-130, 0.0]
B1loc = np.r_[-110, 0.0]
rx = dc.Rx.Dipole(M, N)
src0 = dc.Src.Dipole([rx], A0loc, B0loc)
src1 = dc.Src.Dipole([rx], A1loc, B1loc)
src0_ip = dc.Src.Dipole([rx], A0loc, B0loc)
src1_ip = dc.Src.Dipole([rx], A1loc, B1loc)
source_lists = [src0, src1]
source_lists_ip = [src0_ip, src1_ip]
surveyDC = dc.Survey([src0, src1])
sigmaInf = np.ones(mesh.nC) * 1.0
blkind = utils.model_builder.getIndicesSphere(np.r_[0, -150], 40,
mesh.gridCC)
eta = np.zeros(mesh.nC)
eta[blkind] = 0.1
sigma0 = sigmaInf * (1.0 - eta)
self.surveyDC = surveyDC
self.mesh = mesh
self.sigmaInf = sigmaInf
self.sigma0 = sigma0
self.source_lists = source_lists
self.source_lists_ip = source_lists_ip
self.eta = eta
def setUp(self):
np.random.seed(518936)
# Create a cloud of random points from a random gaussian mixture
self.ndim = 2
self.n_components = 3
sigma = np.random.randn(self.n_components, self.ndim, self.ndim)
sigma = np.c_[[sigma[i].dot(sigma[i].T) for i in range(sigma.shape[0])]]
sigma[0] += np.eye(self.ndim)
sigma[1] += np.eye(self.ndim) - 0.25 * np.eye(self.ndim).transpose((1, 0))
self.sigma = sigma
self.means = (
np.abs(np.random.randn(self.n_components, self.ndim))
* np.c_[[-100, 100], [100, 1], [-100, -100]].T
)
self.rv_list = [
multivariate_normal(mean, sigma)
for i, (mean, sigma) in enumerate(zip(self.means, self.sigma))
]
proportions = np.round(np.abs(np.random.rand(self.n_components)), decimals=1)
proportions = np.abs(np.random.rand(self.n_components))
self.proportions = proportions / proportions.sum()
nsample = 1000
self.samples = np.concatenate(
[
rv.rvs(int(nsample * prp))
for i, (rv, prp) in enumerate(zip(self.rv_list, self.proportions))
]
)
self.nsample = self.samples.shape[0]
self.model = mkvc(self.samples)
self.mesh = discretize.TensorMesh(
[np.maximum(1e-1, np.random.randn(self.nsample) ** 2.0)]
)
self.wires = Wires(("s0", self.mesh.nC), ("s1", self.mesh.nC))
self.cell_weights_list = [
np.maximum(1e-1, np.random.randn(self.mesh.nC) ** 2.0),
np.maximum(1e-1, np.random.randn(self.mesh.nC) ** 2.0),
]
self.PlotIt = False
def test_addition(self):
mesh = discretize.TensorMesh([8, 7, 6])
m = np.random.rand(mesh.nC)
reg1 = regularization.Tikhonov(mesh)
reg2 = regularization.Simple(mesh)
reg_a = reg1 + reg2
self.assertTrue(len(reg_a) == 2)
self.assertTrue(reg1(m) + reg2(m) == reg_a(m))
reg_a.test(eps=TOL)
reg_b = 2 * reg1 + reg2
self.assertTrue(len(reg_b) == 2)
self.assertTrue(2 * reg1(m) + reg2(m) == reg_b(m))
reg_b.test(eps=TOL)
reg_c = reg1 + reg2 / 2
self.assertTrue(len(reg_c) == 2)
self.assertTrue(reg1(m) + 0.5 * reg2(m) == reg_c(m))
reg_c.test(eps=TOL)
def setUp(self):
nC = 20
M = discretize.TensorMesh([nC, nC])
y = np.linspace(0.0, 1.0, nC // 2)
rlocs = np.c_[y * 0 + M.vectorCCx[-1], y]
rx = tomo.Rx(locations=rlocs)
source_list = [
tomo.Src(location=np.r_[M.vectorCCx[0], yi], receiver_list=[rx])
for yi in y
]
survey = tomo.Survey(source_list)
problem = tomo.Simulation(M,
survey=survey,
slownessMap=maps.IdentityMap(M))
self.M = M
self.problem = problem
self.survey = survey
def setUp(self):
mesh = discretize.TensorMesh([4, 4, 4])
# Magnetic inducing field parameter (A,I,D)
B = [50000, 90, 0]
# Create a MAGsurvey
rx = mag.Point(np.vstack([[0.25, 0.25, 0.25], [-0.25, -0.25, 0.25]]))
srcField = mag.SourceField([rx], parameters=(B[0], B[1], B[2]))
survey = mag.Survey(srcField)
# Create the forward model operator
sim = mag.Simulation3DIntegral(mesh,
survey=survey,
chiMap=maps.IdentityMap(mesh))
# Compute forward model some data
m = np.random.rand(mesh.nC)
data = sim.make_synthetic_data(m, add_noise=True)
reg = regularization.Sparse(mesh)
reg.mref = np.zeros(mesh.nC)
reg.norms = np.c_[0, 1, 1, 1]
reg.eps_p, reg.eps_q = 1e-3, 1e-3
# Data misfit function
dmis = data_misfit.L2DataMisfit(data)
dmis.W = 1.0 / data.relative_error
# Add directives to the inversion
opt = optimization.ProjectedGNCG(maxIter=2,
lower=-10.0,
upper=10.0,
maxIterCG=2)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt)
self.mesh = mesh
self.invProb = invProb
self.sim = sim
def setUp(self):
mesh = discretize.TensorMesh([np.ones(n) * 5 for n in [10, 11, 12]],
[0, 0, -30])
x = np.linspace(5, 10, 3)
XYZ = utils.ndgrid(x, x, np.r_[0.0])
srcLoc = np.r_[0, 0, 0.0]
receiver_list0 = survey.BaseRx(XYZ)
Src0 = survey.BaseSrc(receiver_list=[receiver_list0], location=srcLoc)
receiver_list1 = survey.BaseRx(XYZ)
Src1 = survey.BaseSrc(receiver_list=[receiver_list1], location=srcLoc)
receiver_list2 = survey.BaseRx(XYZ)
Src2 = survey.BaseSrc(receiver_list=[receiver_list2], location=srcLoc)
receiver_list3 = survey.BaseRx(XYZ)
Src3 = survey.BaseSrc(receiver_list=[receiver_list3], location=srcLoc)
Src4 = survey.BaseSrc(
receiver_list=[
receiver_list0,
receiver_list1,
receiver_list2,
receiver_list3,
],
location=srcLoc,
)
source_list = [Src0, Src1, Src2, Src3, Src4]
mysurvey = survey.BaseSurvey(source_list=source_list)
sim = simulation.BaseTimeSimulation(mesh,
time_steps=[(10.0, 3), (20.0, 2)],
survey=mysurvey)
def alias(b, srcInd, timeInd):
return self.F.mesh.edgeCurl.T * b + timeInd
self.F = fields.TimeFields(sim,
knownFields={"b": "F"},
aliasFields={"e": ["b", "E", alias]})
self.Src0 = Src0
self.Src1 = Src1
self.mesh = mesh
self.XYZ = XYZ
self.simulation = sim
def test_vangenuchten_k_m(self):
mesh = discretize.TensorMesh([50])
expmap = maps.ExpMap(nP=mesh.nC)
idnmap = maps.IdentityMap(nP=mesh.nC)
seeds = {
"Ks":
np.random.triangular(np.log(1e-7), np.log(1e-6), np.log(1e-5),
mesh.nC),
"I":
np.random.rand(mesh.nC),
"n":
np.random.rand(mesh.nC) + 1,
"alpha":
np.random.rand(mesh.nC),
}
opts = [
("Ks", dict(KsMap=expmap), 1),
("I", dict(IMap=idnmap), 1),
("n", dict(nMap=idnmap), 1),
("alpha", dict(alphaMap=idnmap), 1),
]
u = np.random.randn(mesh.nC)
for name, opt, nM in opts:
van = richards.empirical.Vangenuchten_k(mesh, **opt)
x0 = np.concatenate([seeds[n] for n in name.split("-")])
def fun(m):
van.model = m
return van(u), van.derivM(u)
print("Vangenuchten_k test m deriv: ", name)
passed = checkDerivative(fun, x0, plotIt=False)
self.assertTrue(passed, True)
def setUp(self):
mesh = discretize.TensorMesh(
[np.ones(n) * 5 for n in [10, 11, 12]], [0, 0, -30]
)
x = np.linspace(5, 10, 3)
XYZ = utils.ndgrid(x, x, np.r_[0.0])
srcLoc = np.r_[0, 0, 0.0]
receiver_list0 = survey.BaseRx(XYZ)
Src0 = survey.BaseSrc([receiver_list0], location=srcLoc)
receiver_list1 = survey.BaseRx(XYZ)
Src1 = survey.BaseSrc([receiver_list1], location=srcLoc)
receiver_list2 = survey.BaseRx(XYZ)
Src2 = survey.BaseSrc([receiver_list2], location=srcLoc)
receiver_list3 = survey.BaseRx(XYZ)
Src3 = survey.BaseSrc([receiver_list3], location=srcLoc)
Src4 = survey.BaseSrc(
[receiver_list0, receiver_list1, receiver_list2, receiver_list3],
location=srcLoc,
)
source_list = [Src0, Src1, Src2, Src3, Src4]
mysurvey = survey.BaseSurvey(source_list=source_list)
self.D = data.Data(mysurvey)
def test_faceDiv(self):
hx, hy, hz = np.r_[1., 2, 3, 4], np.r_[5., 6, 7, 8], np.r_[9., 10, 11,
12]
M = discretize.TreeMesh([hx, hy, hz], levels=2)
M.refine(lambda xc: 2)
# M.plotGrid(showIt=True)
Mr = discretize.TensorMesh([hx, hy, hz])
self.assertEqual(M.nC, Mr.nC)
self.assertEqual(M.nF, Mr.nF)
self.assertEqual(M.nFx, Mr.nFx)
self.assertEqual(M.nFy, Mr.nFy)
self.assertEqual(M.nE, Mr.nE)
self.assertEqual(M.nEx, Mr.nEx)
self.assertEqual(M.nEy, Mr.nEy)
self.assertTrue(np.allclose(Mr.area, M.permuteF * M.area))
self.assertTrue(np.allclose(Mr.edge, M.permuteE * M.edge))
self.assertTrue(np.allclose(Mr.vol, M.permuteCC * M.vol))
A = Mr.faceDiv - M.permuteCC * M.faceDiv * M.permuteF.T
self.assertTrue(np.allclose(A.data, 0))
def test_invPropertyTensor3D(self):
M = discretize.TensorMesh([6, 6, 6])
a1 = np.random.rand(M.nC)
a2 = np.random.rand(M.nC)
a3 = np.random.rand(M.nC)
a4 = np.random.rand(M.nC)
a5 = np.random.rand(M.nC)
a6 = np.random.rand(M.nC)
prop1 = a1
prop2 = np.c_[a1, a2, a3]
prop3 = np.c_[a1, a2, a3, a4, a5, a6]
for prop in [4, prop1, prop2, prop3]:
b = invPropertyTensor(M, prop)
A = makePropertyTensor(M, prop)
B1 = makePropertyTensor(M, b)
B2 = invPropertyTensor(M, prop, returnMatrix=True)
Z = B1 * A - sp.identity(M.nC * 3)
self.assertTrue(np.linalg.norm(Z.todense().ravel(), 2) < TOL)
Z = B2 * A - sp.identity(M.nC * 3)
self.assertTrue(np.linalg.norm(Z.todense().ravel(), 2) < TOL)
def set_G(self, N=20, M=100, p=-0.25, q=0.25, j1=1, jn=60):
"""
Parameters
----------
N: # of data
M: # of model parameters
...
"""
self.N = N
self.M = M
self._mesh = discretize.TensorMesh([M])
jk = np.linspace(j1, jn, N)
self._G = np.zeros((N, self.mesh.nC), dtype=float, order="C")
def g(k):
return np.exp(p * jk[k] * self.mesh.vectorCCx) * np.cos(
np.pi * q * jk[k] * self.mesh.vectorCCx)
for i in range(N):
self._G[i, :] = g(i) * self.mesh.hx
self._jk = jk
def test_mappings(self):
mesh = discretize.TensorMesh([8, 7, 6])
m = np.random.rand(2 * mesh.nC)
wires = maps.Wires(("sigma", mesh.nC), ("mu", mesh.nC))
for regType in ["Tikhonov", "Sparse", "Simple"]:
reg1 = getattr(regularization, regType)(mesh, mapping=wires.sigma)
reg2 = getattr(regularization, regType)(mesh, mapping=wires.mu)
reg3 = reg1 + reg2
self.assertTrue(reg1.nP == 2 * mesh.nC)
self.assertTrue(reg2.nP == 2 * mesh.nC)
self.assertTrue(reg3.nP == 2 * mesh.nC)
print(reg3(m), reg1(m), reg2(m))
self.assertTrue(reg3(m) == reg1(m) + reg2(m))
reg1.test(eps=TOL)
reg2.test(eps=TOL)
reg3.test(eps=TOL)
def setUp(self):
cs = 12.5
npad = 2
hx = [(cs, npad, -1.3), (cs, 21), (cs, npad, 1.3)]
hy = [(cs, npad, -1.3), (cs, 21), (cs, npad, 1.3)]
hz = [(cs, npad, -1.3), (cs, 20)]
mesh = discretize.TensorMesh([hx, hy, hz], x0="CCN")
x = mesh.vectorCCx[(mesh.vectorCCx > -80.0) & (mesh.vectorCCx < 80.0)]
y = mesh.vectorCCy[(mesh.vectorCCy > -80.0) & (mesh.vectorCCy < 80.0)]
Aloc = np.r_[-100.0, 0.0, 0.0]
Bloc = np.r_[100.0, 0.0, 0.0]
M = utils.ndgrid(x - 12.5, y, np.r_[0.0])
N = utils.ndgrid(x + 12.5, y, np.r_[0.0])
radius = 50.0
xc = np.r_[0.0, 0.0, -100]
blkind = utils.model_builder.getIndicesSphere(xc, radius, mesh.gridCC)
sigmaInf = np.ones(mesh.nC) * 1e-2
eta = np.zeros(mesh.nC)
eta[blkind] = 0.1
sigma0 = sigmaInf * (1.0 - eta)
rx = dc.receivers.Dipole(M, N)
src = dc.sources.Dipole([rx], Aloc, Bloc)
survey_dc = dc.survey.Survey([src])
rx_ip = dc.receivers.Dipole(M, N, data_type="apparent_chargeability")
src_ip = dc.sources.Dipole([rx_ip], Aloc, Bloc)
survey_ip = ip.Survey([src_ip])
self.survey_dc = survey_dc
self.survey_ip = survey_ip
self.mesh = mesh
self.sigmaInf = sigmaInf
self.sigma0 = sigma0
self.src = src
self.eta = eta
def test_tensor_to_tree_sub(self):
h1 = np.ones(32)
h2 = np.ones(16)
h1s = [h1]
h2s = [h2]
insert_2 = [4]
for i in range(1, 3):
print(f"Tensor to smaller Tree {i+1}D: ", end="")
h1s.append(h1)
h2s.append(h2)
insert_2.append(4)
mesh1 = discretize.TensorMesh(h1s)
mesh2 = discretize.TreeMesh(h2s)
mesh2.insert_cells([insert_2], [4])
in_put = np.random.rand(mesh1.nC)
out_put = np.empty(mesh2.nC)
# test the three ways of calling...
out1 = volume_average(mesh1, mesh2, in_put, out_put)
assert_array_equal(out1, out_put)
out2 = volume_average(mesh1, mesh2, in_put)
assert_allclose(out1, out2)
Av = volume_average(mesh1, mesh2)
out3 = Av @ in_put
assert_allclose(out1, out3)
# get cells in extent of smaller mesh
cells = mesh1.gridCC < [16] * (i + 1)
if i > 0:
cells = np.all(cells, axis=1)
vol1 = np.sum(mesh1.vol[cells] * in_put[cells])
vol2 = np.sum(mesh2.vol * out3)
print(vol1, vol2)
self.assertAlmostEqual(vol1, vol2)
def test_reciprocal_no_map(self):
expMap = maps.ExpMap(discretize.TensorMesh((3,)))
PM = ReciprocalExample()
self.assertRaises(AttributeError, getattr, PM, "sigma")
PM.sigmaMap = expMap
# PM = pickle.loads(pickle.dumps(PM))
PM.model = np.r_[1.0, 2.0, 3.0]
assert np.all(PM.sigma == np.exp(np.r_[1.0, 2.0, 3.0]))
assert np.all(PM.rho == 1.0 / np.exp(np.r_[1.0, 2.0, 3.0]))
PM.rho = np.r_[1.0, 2.0, 3.0]
assert PM.sigmaMap is None
assert PM.sigmaDeriv == 0
assert np.all(PM.sigma == 1.0 / np.r_[1.0, 2.0, 3.0])
PM.sigmaMap = expMap
assert len(PM.sigmaMap) == 1
# PM = pickle.loads(pickle.dumps(PM))
assert np.all(PM.rho == 1.0 / np.exp(np.r_[1.0, 2.0, 3.0]))
assert np.all(PM.sigma == np.exp(np.r_[1.0, 2.0, 3.0]))
assert isinstance(PM.sigmaDeriv.todense(), np.ndarray)
def test_segmented_tree(self):
hx = np.ones(16) * 1.0
hy = np.ones(16) * 2.0
hz = np.ones(16) * 3.0
px = np.r_[0, 3, 5]
py = np.r_[0, 3, 5]
pz = np.r_[2.0, 3.0, 4.0]
xorig = np.r_[0.0, 0.0, 0.0]
tensor_mesh = discretize.TensorMesh((hx, hy, hz), x0=xorig)
tree_mesh = discretize.TreeMesh((hx, hy, hz), x0=xorig)
tree_mesh.refine(4)
locs = np.c_[px, py, pz]
out1 = segmented_line_current_source_term(tensor_mesh, locs)
out2 = segmented_line_current_source_term(tree_mesh, locs)
sort1 = np.lexsort(tensor_mesh.edges.T)
sort2 = np.lexsort(tree_mesh.edges.T)
np.testing.assert_allclose(out1[sort1], out2[sort2])
def doTestFace(h, rep, fast, meshType, invProp=False, invMat=False):
if meshType == 'Curv':
hRect = discretize.utils.exampleLrmGrid(h, 'rotate')
mesh = discretize.CurvilinearMesh(hRect)
elif meshType == 'Tree':
mesh = discretize.TreeMesh(h, levels=3)
mesh.refine(lambda xc: 3)
elif meshType == 'Tensor':
mesh = discretize.TensorMesh(h)
v = np.random.rand(mesh.nF)
sig = np.random.rand(1) if rep is 0 else np.random.rand(mesh.nC * rep)
def fun(sig):
M = mesh.getFaceInnerProduct(sig, invProp=invProp, invMat=invMat)
Md = mesh.getFaceInnerProductDeriv(sig,
invProp=invProp,
invMat=invMat,
doFast=fast)
return M * v, Md(v)
print(meshType, 'Face', h, rep, fast,
('harmonic' if invProp and invMat else 'standard'))
return discretize.Tests.checkDerivative(fun, sig, num=5, plotIt=False)
def setUp(self):
aSpacing = 2.5
nElecs = 5
surveySize = nElecs * aSpacing - aSpacing
cs = surveySize / nElecs / 4
self.mesh = discretize.TensorMesh(
[
[(cs, 10, -1.3), (cs, surveySize / cs), (cs, 10, 1.3)],
[(cs, 3, -1.3), (cs, 3, 1.3)],
# [(cs, 5, -1.3), (cs, 10)]
],
"CN",
)
survey_end_points = np.array([-surveySize / 2, surveySize / 2, 0, 0])
source_list = generate_dcip_sources_line(
"dipole-dipole", "volt", "2D", survey_end_points, 0.0, 5, 2.5
)
self.d_d_survey = dc.survey.Survey(source_list)
source_list = generate_dcip_sources_line(
"dipole-pole", "volt", "2D", survey_end_points, 0.0, 5, 2.5
)
self.d_p_survey = dc.survey.Survey(source_list)
source_list = generate_dcip_sources_line(
"pole-dipole", "volt", "2D", survey_end_points, 0.0, 5, 2.5
)
self.p_d_survey = dc.survey.Survey(source_list)
source_list = generate_dcip_sources_line(
"pole-pole", "volt", "2D", survey_end_points, 0.0, 5, 2.5
)
self.p_p_survey = dc.survey.Survey(source_list)
def setUp(self):
mesh = discretize.TensorMesh([np.ones(n) * 5 for n in [10, 11, 12]],
[0, 0, -30])
x = np.linspace(5, 10, 3)
XYZ = utils.ndgrid(x, x, np.r_[0.0])
srcLoc = np.r_[0, 0, 0.0]
receiver_list0 = survey.BaseRx(XYZ)
Src0 = survey.BaseSrc([receiver_list0], location=srcLoc)
receiver_list1 = survey.BaseRx(XYZ)
Src1 = survey.BaseSrc([receiver_list1], location=srcLoc)
receiver_list2 = survey.BaseRx(XYZ)
Src2 = survey.BaseSrc([receiver_list2], location=srcLoc)
receiver_list3 = survey.BaseRx(XYZ)
Src3 = survey.BaseSrc([receiver_list3], location=srcLoc)
Src4 = survey.BaseSrc(
[receiver_list0, receiver_list1, receiver_list2, receiver_list3],
location=srcLoc,
)
source_list = [Src0, Src1, Src2, Src3, Src4]
mysurvey = survey.BaseSurvey(source_list=source_list)
sim = simulation.BaseSimulation(mesh=mesh, survey=mysurvey)
self.F = fields.Fields(
sim,
knownFields={"e": "E"},
aliasFields={
"b": ["e", "F", (lambda e, ind: self.F.mesh.edgeCurl * e)]
},
)
self.Src0 = Src0
self.Src1 = Src1
self.mesh = mesh
self.XYZ = XYZ
self.simulation = sim
def setUp(self):
cs = 10.0
ncx, ncy, ncz = 30.0, 30.0, 30.0
npad = 10.0
hx = [(cs, npad, -1.5), (cs, ncx), (cs, npad, 1.5)]
hy = [(cs, npad, -1.5), (cs, ncy), (cs, npad, 1.5)]
hz = [(cs, npad, -1.5), (cs, ncz), (cs, npad, 1.5)]
self.mesh = discretize.TensorMesh([hx, hy, hz], "CCC")
mapping = maps.ExpMap(self.mesh)
self.frequency = 1.0
self.prob_e = fdem.Simulation3DElectricField(self.mesh,
sigmaMap=mapping)
self.prob_b = fdem.Simulation3DMagneticFluxDensity(self.mesh,
sigmaMap=mapping)
self.prob_h = fdem.Simulation3DMagneticField(self.mesh,
sigmaMap=mapping)
self.prob_j = fdem.Simulation3DCurrentDensity(self.mesh,
sigmaMap=mapping)
loc = np.r_[0.0, 0.0, 0.0]
self.location = utils.mkvc(
self.mesh.gridCC[utils.closestPoints(self.mesh, loc, "CC"), :])
def setUp(self):
np.random.seed(518936)
# Create a cloud of random points from a random gaussian mixture
self.ndim = 2
self.n_components = 2
sigma = np.random.randn(self.n_components, self.ndim, self.ndim)
sigma = np.c_[[
sigma[i].dot(sigma[i].T) for i in range(sigma.shape[0])
]]
sigma[0] += np.eye(self.ndim)
sigma[1] += np.eye(self.ndim) - 0.25 * np.eye(self.ndim).transpose(
(1, 0))
self.sigma = sigma
self.means = (np.abs(np.random.randn(self.ndim, self.ndim)) *
np.c_[[100.0, -100.0]])
self.rv0 = multivariate_normal(self.means[0], self.sigma[0])
self.rv1 = multivariate_normal(self.means[1], self.sigma[1])
self.proportions = np.r_[0.6, 0.4]
self.nsample = 1000
self.s0 = self.rv0.rvs(int(self.nsample * self.proportions[0]))
self.s1 = self.rv1.rvs(int(self.nsample * self.proportions[1]))
self.samples = np.r_[self.s0, self.s1]
self.model = mkvc(self.samples)
self.mesh = discretize.TensorMesh(
[np.maximum(1e-1,
np.random.randn(self.nsample)**2.0)])
self.wires = Wires(("s0", self.mesh.nC), ("s1", self.mesh.nC))
self.cell_weights_list = [
np.maximum(1e-1,
np.random.randn(self.mesh.nC)**2.0),
np.maximum(1e-1,
np.random.randn(self.mesh.nC)**2.0),
]
self.PlotIt = False
def run(plotIt=True):
sz = [16, 16]
tM = discretize.TensorMesh(sz)
qM = discretize.TreeMesh(sz)
def refine(cell):
if np.sqrt(((np.r_[cell.center] - 0.5)**2).sum()) < 0.4:
return 4
return 3
qM.refine(refine)
rM = discretize.CurvilinearMesh(
discretize.utils.exampleLrmGrid(sz, 'rotate'))
if not plotIt:
return
fig, axes = plt.subplots(1, 3, figsize=(14, 5))
opts = {}
tM.plotGrid(ax=axes[0], **opts)
axes[0].set_title('TensorMesh')
qM.plotGrid(ax=axes[1], **opts)
axes[1].set_title('TreeMesh')
rM.plotGrid(ax=axes[2], **opts)
axes[2].set_title('CurvilinearMesh')
def setUp(self):
mesh = self.get_mesh()
params = richards.empirical.HaverkampParams().celia1990
k_fun, theta_fun = richards.empirical.haverkamp(mesh, **params)
self.setup_maps(mesh, k_fun, theta_fun)
bc, h = self.get_conditions(mesh)
time_steps = [(40, 3), (60, 3)]
time_mesh = discretize.TensorMesh([time_steps])
rx_list = self.get_rx_list(time_mesh.nodes_x)
survey = richards.Survey(rx_list)
prob = richards.SimulationNDCellCentered(
mesh,
survey=survey,
hydraulic_conductivity=k_fun,
water_retention=theta_fun,
root_finder_tol=1e-6,
debug=False,
boundary_conditions=bc,
initial_conditions=h,
do_newton=False,
method="mixed",
)
prob.time_steps = time_steps
prob.solver = Solver
self.h0 = h
self.mesh = mesh
self.Ks = params["Ks"] * np.ones(self.mesh.nC)
self.A = params["A"] * np.ones(self.mesh.nC)
self.theta_s = params["theta_s"] * np.ones(self.mesh.nC)
self.prob = prob
self.survey = survey
self.setup_model()
def run(plotIt=True):
M = discretize.TensorMesh([32, 32])
v = discretize.utils.random_model(M.vnC, seed=789)
v = discretize.utils.mkvc(v)
O = discretize.TreeMesh([32, 32])
def function(cell):
if (cell.center[0] < 0.75 and cell.center[0] > 0.25
and cell.center[1] < 0.75 and cell.center[1] > 0.25):
return 5
if (cell.center[0] < 0.9 and cell.center[0] > 0.1
and cell.center[1] < 0.9 and cell.center[1] > 0.1):
return 4
return 3
O.refine(function)
P = M.getInterpolationMat(O.gridCC, 'CC')
ov = P * v
if not plotIt:
return
fig, axes = plt.subplots(1, 2, figsize=(10, 5))
out = M.plotImage(v, grid=True, ax=axes[0])
cb = plt.colorbar(out[0], ax=axes[0])
cb.set_label("Random Field")
axes[0].set_title('TensorMesh')
out = O.plotImage(ov, grid=True, ax=axes[1], clim=[0, 1])
cb = plt.colorbar(out[0], ax=axes[1])
cb.set_label("Random Field")
axes[1].set_title('TreeMesh')
def run(plotIt=True, n=60):
np.random.seed(5)
# Here we are going to rearrange the equations:
# (phi_ - phi)/dt = A*(d2fdphi2*(phi_ - phi) + dfdphi - L*phi_)
# (phi_ - phi)/dt = A*(d2fdphi2*phi_ - d2fdphi2*phi + dfdphi - L*phi_)
# (phi_ - phi)/dt = A*d2fdphi2*phi_ + A*( - d2fdphi2*phi + dfdphi - L*phi_)
# phi_ - phi = dt*A*d2fdphi2*phi_ + dt*A*(- d2fdphi2*phi + dfdphi - L*phi_)
# phi_ - dt*A*d2fdphi2 * phi_ = dt*A*(- d2fdphi2*phi + dfdphi - L*phi_) + phi
# (I - dt*A*d2fdphi2) * phi_ = dt*A*(- d2fdphi2*phi + dfdphi - L*phi_) + phi
# (I - dt*A*d2fdphi2) * phi_ = dt*A*dfdphi - dt*A*d2fdphi2*phi - dt*A*L*phi_ + phi
# (dt*A*d2fdphi2 - I) * phi_ = dt*A*d2fdphi2*phi + dt*A*L*phi_ - phi - dt*A*dfdphi
# (dt*A*d2fdphi2 - I - dt*A*L) * phi_ = (dt*A*d2fdphi2 - I)*phi - dt*A*dfdphi
h = [(0.25, n)]
M = discretize.TensorMesh([h, h])
# Constants
D = a = epsilon = 1.
I = discretize.utils.speye(M.nC)
# Operators
A = D * M.faceDiv * M.cellGrad
L = epsilon**2 * M.faceDiv * M.cellGrad
duration = 75
elapsed = 0.
dexp = -5
phi = np.random.normal(loc=0.5, scale=0.01, size=M.nC)
ii, jj = 0, 0
PHIS = []
capture = np.logspace(-1, np.log10(duration), 8)
while elapsed < duration:
dt = min(100, np.exp(dexp))
elapsed += dt
dexp += 0.05
dfdphi = a**2 * 2 * phi * (1 - phi) * (1 - 2 * phi)
d2fdphi2 = discretize.utils.sdiag(a**2 * 2 * (1 - 6 * phi * (1 - phi)))
MAT = (dt * A * d2fdphi2 - I - dt * A * L)
rhs = (dt * A * d2fdphi2 - I) * phi - dt * A * dfdphi
phi = Solver(MAT) * rhs
if elapsed > capture[jj]:
PHIS += [(elapsed, phi.copy())]
jj += 1
if ii % 10 == 0:
print(ii, elapsed)
ii += 1
if plotIt:
fig, axes = plt.subplots(2, 4, figsize=(14, 6))
axes = np.array(axes).flatten().tolist()
for ii, ax in zip(np.linspace(0, len(PHIS) - 1, len(axes)), axes):
ii = int(ii)
M.plotImage(PHIS[ii][1], ax=ax)
ax.axis('off')
ax.set_title('Elapsed Time: {0:4.1f}'.format(PHIS[ii][0]))
def test_ParametricSplineMap(self):
M2 = discretize.TensorMesh([np.ones(10), np.ones(10)], "CN")
x = M2.vectorCCx
mParamSpline = maps.ParametricSplineMap(M2, x, normal="Y", order=1)
self.assertTrue(mParamSpline.test())
self.assertTrue(mParamSpline.testVec())
def test_ParametricPolyMap(self):
M2 = discretize.TensorMesh([np.ones(10), np.ones(10)], "CN")
mParamPoly = maps.ParametricPolyMap(M2, 2, logSigma=True, normal="Y")
self.assertTrue(mParamPoly.test(m=np.r_[1.0, 1.0, 0.0, 0.0, 0.0]))
self.assertTrue(mParamPoly.testVec(m=np.r_[1.0, 1.0, 0.0, 0.0, 0.0]))
