def test_ordinary():
x = np.array([9.7, 43.8])
y = np.array([47.6, 24.6])
v = np.array([1.22, 2.822])
xi = 18.8
yi = 67.9
result_v_est = 1.636390
result_v_var = 0.420099
print(kriging.ordinary(x, y, v, xi, yi, model))
assert (np.allclose(kriging.ordinary(x, y, v, xi, yi, model),
(result_v_est, result_v_var),
rtol=1e-4))
def orthonormal_residuals(x, y, v, model_function, return_values=False):
"""
Cross validation function based on orthonormal residues.
reference: Peter K Kitanidis, Introduction to geostatistics:
applications in hydrogeology, 1997, pp. 86--96
Arguments:
x,y,v : the data points
model_function : a handle to the variogram model function
Returns:
success : true if model is acceptable, false otherwise
Q1: the mean of the normalized error
Q2: the mean of the squared normalized error
at locations xi,yi
MSE : the mean square error
cR : the geometric mean of the kriging variances
v_est : estimated kriging values
v_var : variances of estimated kriging values
v : true values
"""
n = x.shape[0]
p = np.random.permutation(n)
# random permutation of input
x = x[p]
y = y[p]
v = v[p]
# number of degrees of freedom
df = n - 1
kriging_error = np.zeros(df)
squared_error = np.zeros(df)
normalized_error = np.zeros(df)
squared_norm_error = np.zeros(df)
v_est = np.zeros(df)
v_var = np.zeros(df)
for i in np.arange(df):
v_est[i], v_var[i] = kriging.ordinary(
x[0:i + 1], y[0:i + 1], v[0:i + 1],
x[i + 1], y[i + 1], model_function)
kriging_error[i] = v_est[i] - v[i + 1]
squared_error = kriging_error**2
normalized_error = kriging_error / np.sqrt(v_var)
squared_norm_error = normalized_error**2
Q1 = np.mean(normalized_error)
Q2 = np.mean(squared_norm_error)
MSE = np.mean(squared_error)
cR = np.exp(np.sum(np.log(v_var)) / df)
L = chi2.ppf(0.025, df) / df
U = chi2.ppf(0.975, df) / df
success = (np.abs(Q1) <= 2 / np.sqrt(df)) and (Q2 <= U and Q2 >= L)
if (return_values):
return success, Q1, Q2, MSE, cR, v_est, v_var, v, normalized_error
else:
return success, Q1, Q2, MSE, cR
def test_ordinaryk():
import os.path
import numpy as np
import variance as vrc
import fit
import test_data.point as p
import kriging as kr
data = read_data(os.path.dirname(os.path.realpath(__file__)) + "/test_data/necoldem.dat")
print("calculte empirical semivariance")
hh = 50
lags = range(0, 3000, hh)
gamma = vrc.semivar(data, lags, hh)
#covariance = vrc.covar(data, lags, hh)
print("fit semivariogram")
# choose the model with lowest rmse
semivariograms=[]
semivariograms.append(fit.fitsemivariogram(data, gamma, fit.spherical))
semivariograms.append(fit.fitsemivariogram(data, gamma, fit.linear))
semivariograms.append(fit.fitsemivariogram(data, gamma, fit.gaussian))
semivariograms.append(fit.fitsemivariogram(data, gamma, fit.exponential))
rsmes = [rmse(gamma[0], i(gamma[0])) for i in semivariograms]
semivariogram = semivariograms[rsmes.index(min(rsmes))]
print("################test point 337000, 4440911 ")
x = p.Point(337000, 4440911)
p1 = prepare_interpolation_data(x, data)
print("ordinary kriging")
print(kr.ordinary(np.array(p1[0]), semivariogram)[0:2])
print("simple kriging")
print(kr.simple(np.array(p1[0]), p1[1], semivariogram)[0:2])
print("################test a point from the original data")
x = p.Point(data[1, 0], data[1, 1])
p1 = prepare_interpolation_data(x, data)
print("ordinary kriging")
print(kr.ordinary(np.array(p1[0]), semivariogram)[0:2])
print("simple kriging")
print(kr.simple(np.array(p1[0]), p1[1], semivariogram)[0:2])
def main():
"""
Estimates the cobalt concentration at (3.0, 3.0) and compute variance.
Provides also 95% confidence interval
"""
xi = 3.0
yi = 3.0
jura_data = np.genfromtxt('data.txt', names=True)
v_est, v_var = kriging.ordinary(jura_data['X'], jura_data['Y'],
jura_data['Co'], xi, yi, model_function)
print('Cobalt concentration:', v_est)
print('Variance:', v_var)
print('95% confidence interval:', v_est - 2 * np.sqrt(v_var),
v_est + 2 * np.sqrt(v_var))
def interpolate_surface():
import os.path
import numpy as np
import variance as vrc
import fit
import test_data.point as p
import kriging as kr
from bokeh.plotting import figure
from bokeh.io import output_file, save
data = read_data(os.path.dirname(os.path.realpath(__file__)) + "/test_data/necoldem.dat")
##TODO the semivariogram should be computed for every surface cell!!!
print("calculte empirical semivariance")
hh = 50
lags = range(0, 3000, hh)
gamma = vrc.semivar(data, lags, hh)
#covariance = vrc.covar(data, lags, hh)
print("fit semivariogram")
# choose the model with lowest rmse
semivariograms=[]
semivariograms.append(fit.fitsemivariogram(data, gamma, fit.spherical))
semivariograms.append(fit.fitsemivariogram(data, gamma, fit.linear))
semivariograms.append(fit.fitsemivariogram(data, gamma, fit.gaussian))
semivariograms.append(fit.fitsemivariogram(data, gamma, fit.exponential))
rsmes = [rmse(gamma[0], i(gamma[0])) for i in semivariograms]
semivariogram = semivariograms[rsmes.index(min(rsmes))]
# define surface properties
x0,x1 = data[:,0].min(),data[:,0].max()
y0,y1 = data[:,1].min(),data[:,1].max()
dx,dy = x1-x0, y1-y0
dsize =min(dx/100.0, dy/100.0)
nx = int(np.ceil(dx/dsize))
ny = int(np.ceil(dy/dsize))
# initialize empty arrays to store interpolated surfaces and errors
surface_ordinary = np.zeros((nx,ny))
error_ordinary = np.zeros((nx,ny))
surface_simple = np.zeros((nx,ny))
error_simple = np.zeros((nx,ny))
print("Executing simple and ordinary kriging, this will take some time")
# execute kriging for each surface cell
for i in range(nx):
for j in range(ny):
x = p.Point(x0+i*dsize, y0+j*dsize)
new_data, mu = prepare_interpolation_data_array(x,data,n=10) #### TODO: this should use spatial indexing
ordinary = kr.ordinary(np.array(new_data), semivariogram)
surface_ordinary[i,j] = ordinary[0]
error_ordinary[i,j] = ordinary[1]
simple = kr.simple(np.array(new_data), mu, semivariogram)
surface_simple[i,j] = simple[0]
error_simple[i,j] = simple[1]
# save arrays to disk, array are transposed to have the correct x,y coordimates
np.savez(os.path.dirname(os.path.realpath(__file__)) +"/test_data/surfaces.npz",surface_ordinary=surface_ordinary.T,
error_ordinary=error_ordinary.T, surface_simple=surface_simple.T, error_simple=error_simple.T,
surface_difference= surface_ordinary-surface_simple)