def test_auto_fit(self):
x = y = range(60)
pos = gs.generate_grid([x, y])
model = gs.Gaussian(dim=2, var=1, len_scale=10)
srf = gs.SRF(model,
seed=20170519,
normalizer=gs.normalizer.LogNormal())
srf(pos)
ids = np.arange(srf.field.size)
samples = np.random.RandomState(20210201).choice(ids,
size=60,
replace=False)
# sample conditioning points from generated field
cond_pos = pos[:, samples]
cond_val = srf.field[samples]
krige = gs.krige.Ordinary(
model=gs.Stable(dim=2),
cond_pos=cond_pos,
cond_val=cond_val,
normalizer=gs.normalizer.BoxCox(),
fit_normalizer=True,
fit_variogram=True,
)
# test fitting during kriging
self.assertTrue(np.abs(krige.normalizer.lmbda - 0.0) < 1e-1)
self.assertAlmostEqual(krige.model.len_scale, 10.2677, places=4)
self.assertAlmostEqual(
krige.model.sill,
krige.normalizer.normalize(cond_val).var(),
places=4,
)
# test fitting during vario estimate
bin_center, gamma, normalizer = gs.vario_estimate(
cond_pos,
cond_val,
normalizer=gs.normalizer.BoxCox,
fit_normalizer=True,
)
model = gs.Stable(dim=2)
model.fit_variogram(bin_center, gamma)
self.assertAlmostEqual(model.var, 0.6426670183, places=4)
self.assertAlmostEqual(model.len_scale, 9.635193952, places=4)
self.assertAlmostEqual(model.nugget, 0.001617908408, places=4)
self.assertAlmostEqual(model.alpha, 2.0, places=4)
def fit_model_var(coords_df, x_c, y_c, values):
# fit the model varigrom to the experimental variogram
bin_num = 40 # number of bins in the experimental variogram
# first get the coords and determine distances
x_delta = max(x_c) - min(x_c) # distance across x coords
y_delta = max(y_c) - min(y_c) # distance across y coords
max_dist = np.sqrt(
np.square(x_delta +
y_delta)) / 4 # assume correlated over 1/4 of distance
# setup bins for the variogram
bins_c = np.linspace(0, max_dist,
bin_num) # bin edges in variogram, bin_num of bins
# compute the experimental variogram
bin_cent_c, gamma_c = gs.vario_estimate_unstructured((x_c, y_c), values,
bins_c)
# bin_center_c is the "lag" of the bin, gamma_c is the value
gamma_c = smooth(
gamma_c, 5
) # smooth the experimental variogram to help fitting - moving window with 5 samples
# fit the model variogram
# potential models are: Gaussian, Exponential, Matern, Rational, Stable, Linear,
# Circular, Spherical, and Intersection
fit_var = gs.Stable(dim=2)
fit_var.fit_variogram(bin_cent_c,
gamma_c,
nugget=False,
estimator='cressie') # fit the model variogram
# print('max distance', max_dist,'var len scale', fit_var.len_scale)
# check to see of range of varigram is very small (problem with fit), it so, set it to a value
# also check to see if it is too long and set it to a value
if fit_var.len_scale < max_dist / 3: # check if too short
fit_var.len_scale = max_dist / 3 # set to value
# print('too short, set len_scale to: ', max_dist/3)
elif fit_var.len_scale > max_dist * 1.5: # check if too long
fit_var.len_scale = max_dist # set to value
# print('too long, set len_scale to: ', max_dist)
plt_var = False
if plt_var:
# plot the variogram to show fit and print out variogram paramters
# should make it save to pdf file
ax1 = fit_var.plot(x_max=max_dist) # plot model variogram
ax1.plot(bin_cent_c, gamma_c) # plot experimental variogram
# krig_plots.savefig()
plt.close('all')
return fit_var
def test_fit_directional(self):
model = gs.Stable(dim=3)
bins = [0, 3, 6, 9, 12]
model.len_scale_bounds = [0, 20]
bin_center, emp_vario, counts = gs.vario_estimate(
*(self.pos, self.field, bins),
direction=model.main_axes(),
mesh_type="structured",
return_counts=True,
)
# check if this succeeds
model.fit_variogram(bin_center, emp_vario, sill=1, return_r2=True)
self.assertTrue(1 > model.anis[0] > model.anis[1])
model.fit_variogram(bin_center, emp_vario, sill=1, anis=[0.5, 0.25])
self.assertTrue(15 > model.len_scale)
model.fit_variogram(bin_center, emp_vario, sill=1, weights=counts)
len_save = model.len_scale
model.fit_variogram(bin_center, emp_vario, sill=1, weights=counts[0])
self.assertAlmostEqual(len_save, model.len_scale)
# catch wrong dim for dir.-vario
with self.assertRaises(ValueError):
model.fit_variogram(bin_center, emp_vario[:2])
#
# Now we want to interpolate the "measured" samples
# and we want to normalize the given data with the BoxCox transformation.
#
# Here we set up the kriging routine and use a :any:`Stable` model, that should
# be fitted automatically to the given data
# and we pass the :any:`BoxCox` normalizer in order to gain normality.
#
# The normalizer will be fitted automatically to the data,
# by setting ``fit_normalizer=True``.
#
# The covariance/variogram model will be fitted by an automatic workflow
# by setting ``fit_variogram=True``.
krige = gs.krige.Ordinary(
model=gs.Stable(dim=2),
cond_pos=cond_pos,
cond_val=cond_val,
normalizer=gs.normalizer.BoxCox(),
fit_normalizer=True,
fit_variogram=True,
)
###############################################################################
# First, let's have a look at the fitting results:
print(krige.model)
print(krige.normalizer)
###############################################################################
# As we see, it went quite well. Variance is a bit underestimated, but
def test_raise_error(self):
self.assertRaises(ValueError, gs.CondSRF, gs.Gaussian())
krige = gs.krige.Ordinary(gs.Stable(), self.cond_pos, self.cond_val)
self.assertRaises(ValueError, gs.CondSRF, krige, generator="unknown")
ax = fig.add_subplot(121)
u = np.linspace(0, 2 * np.pi, 100)
x = np.cos(u)
y = np.sin(u)
ax.plot(x, y, color="b", alpha=0.1)
ax.scatter(norm[0], norm[1])
ax.set_aspect("equal")
else:
ax = fig.add_subplot(121)
ax.bar(-1, np.sum(np.isclose(norm, -1)), color="C0")
ax.bar(1, np.sum(np.isclose(norm, 1)), color="C0")
ax.set_xticks([-1, 1])
ax.set_xticklabels(("-1", "1"))
ax.set_title("Direction sampling")
ax = fig.add_subplot(122)
x = np.linspace(0, 10 / generator.model.integral_scale)
y = generator.model.spectral_rad_pdf(x)
ax.plot(x, y, label="radial spectral density")
sample_in = np.sum(rad <= np.max(x))
ax.hist(rad[rad <= np.max(x)], bins=sample_in // 50, density=True)
ax.set_xlim([0, np.max(x)])
ax.set_title("Radius samples shown {}/{}".format(sample_in, len(rad)))
ax.legend()
fig.show()
model = gs.Stable(dim=3, alpha=1.5)
srf = gs.SRF(model, seed=2020)
plot_rand_meth_samples(srf.generator)
# bin_center, gamma = gs.vario_estimate((x, y), field) # # # Here, we can use :class:`skg.Variogram <skgstat.Variogram>`. # From the shown arguments, :func:`estimator <skgstat.Variogram.estimator>` and # :func:`bin_func <skgstat.Variogram.bin_func>` are using the default values: V = skg.Variogram(coords, field, n_lags=21, estimator='matheron', maxlag=45, bin_func='even') bin_center, gamma = V.get_empirical(bin_center=True) # %% # And finally, the exact same code from the GSTools docs can be called: # fit the variogram with a stable model. (no nugget fitted) fit_model = gs.Stable(dim=2) fit_model.fit_variogram(bin_center, gamma, nugget=False) # %% # Output the model ax = fit_model.plot(x_max=max(bin_center)) ax.scatter(bin_center, gamma) print(fit_model) # %% # # 6.1.2 ``bin_center=False`` # ~~~~~~~~~~~~~~~~~~~~~~~~~~ # # It is important to understand, that ``gstools`` and ``skgstat`` are handling lag bins different. # While ``skgstat`` uses the upper limit, ``gstools`` assumes the bin center.
def test_raise(self):
# no cond_pos/cond_val given
self.assertRaises(ValueError, gs.krige.Krige, gs.Stable(), None, None)
scale of a covariance model. We provide two common scales with the covariance
model.
Integral scale
--------------
The `integral scale <https://en.wikipedia.org/wiki/Integral_length_scale>`_
of a covariance model is calculated by:
.. math:: I = \int_0^\infty \rho(r) dr
You can access it by:
"""
import gstools as gs
model = gs.Stable(dim=3, var=2.0, len_scale=10)
print("Main integral scale:", model.integral_scale)
print("All integral scales:", model.integral_scale_vec)
###############################################################################
# You can also specify integral length scales like the ordinary length scale,
# and len_scale/anis will be recalculated:
model = gs.Stable(dim=3, var=2.0, integral_scale=[10, 4, 2])
print("Anisotropy ratios:", model.anis)
print("Main length scale:", model.len_scale)
print("All length scales:", model.len_scale_vec)
print("Main integral scale:", model.integral_scale)
print("All integral scales:", model.integral_scale_vec)
The resulting kriging variance describes the error variance of the log-values of the target variable. In this example we will use ordinary kriging. """ import numpy as np import gstools as gs # condtions cond_pos = [0.3, 1.9, 1.1, 3.3, 4.7] cond_val = [0.47, 0.56, 0.74, 1.47, 1.74] # resulting grid gridx = np.linspace(0.0, 15.0, 151) # stable covariance model model = gs.Stable(dim=1, var=0.5, len_scale=2.56, alpha=1.9) ############################################################################### # In order to result in log-normal kriging, we will use the :any:`LogNormal` # Normalizer. This is a parameter-less normalizer, so we don't have to fit it. normalizer = gs.normalizer.LogNormal ############################################################################### # Now we generate the interpolated field as well as the mean field. # This can be done by setting `only_mean=True` in :any:`Krige.__call__`. # The result is then stored as `mean_field`. # # In terms of log-normal kriging, this mean represents the geometric mean of # the field. krige = gs.krige.Ordinary(model, cond_pos, cond_val, normalizer=normalizer) # interpolate the field
