def exp_semivariogram(records, stations):
'''
Public function for establishing the experimental semivariogram.
Parameters
----------
records : array_like, shape ``(p,n)``
Vector for which semivariogram is going to be calculated.
stations : array_like shape ``(n,2)``
Vector with the `x,y` coordinates of the measurement stations.
Returns
-------
experimental_sv : array_like, shape ``(n,n)``
Experimental semivariogram vector composed of lag and semivariogram
record_covariance_matrix : array_like, shape ``(n,n)``
Covariance matrix for the recorded data.
'''
## Removal of no precipitation events
WetMeas = []
for i in xrange(0,len(records)):
if np.max(records[i]) > 3:
WetMeas.append(records[i])
## Measurement covariance
record_covariance_matrix = np.cov(np.transpose(WetMeas))
Dis = dist.between(stations)
## Experimental Semivariogram
experimental_sv = []
for i in xrange(0,len(record_covariance_matrix)-1):
for j in xrange(i+1,len(record_covariance_matrix)):
Cov = record_covariance_matrix[i][j]
Lag = Dis[i][j]
experimental_sv.append([Lag, Cov])
experimental_sv = np.array(experimental_sv)
Lag2, Cov2 = _regul(experimental_sv[:,0],experimental_sv[:,1],15,3)
experimental_sv = np.transpose(np.vstack((Lag2,Cov2)))
return experimental_sv, record_covariance_matrix
def exp_semivariogram(records, stations):
'''
Public function for establishing the experimental semivariogram.
Parameters
----------
records : array_like, shape ``(p,n)``
Vector for which semivariogram is going to be calculated.
stations : array_like shape ``(n,2)``
Vector with the `x,y` coordinates of the measurement stations.
Returns
-------
experimental_sv : array_like, shape ``(n,n)``
Experimental semivariogram vector composed of lag and semivariogram
record_covariance_matrix : array_like, shape ``(n,n)``
Covariance matrix for the recorded data.
'''
## Removal of no precipitation events
WetMeas = []
for i in xrange(0, len(records)):
if np.max(records[i]) > 3:
WetMeas.append(records[i])
## Measurement covariance
record_covariance_matrix = np.cov(np.transpose(WetMeas))
Dis = dist.between(stations)
## Experimental Semivariogram
experimental_sv = []
for i in xrange(0, len(record_covariance_matrix) - 1):
for j in xrange(i + 1, len(record_covariance_matrix)):
Cov = record_covariance_matrix[i][j]
Lag = Dis[i][j]
experimental_sv.append([Lag, Cov])
experimental_sv = np.array(experimental_sv)
Lag2, Cov2 = _regul(experimental_sv[:, 0], experimental_sv[:, 1], 15, 3)
experimental_sv = np.transpose(np.vstack((Lag2, Cov2)))
return experimental_sv, record_covariance_matrix
def ns_kriging_mm(data, stations, bp, x_opt_st, mod_opt_st, targets,
candidate_var=[variogram_fit.spherical_sv,],
candidate_tag=['Spherical',], verbose=False,
ncs=3, krig_type='Ord'):
'''
t1_var : list
Parameters of the tier 1 variogram (variogram of the kriging
parameters) to be interpolated at each interval
the method uses Ordinary Kriging using multi-precipitation model
'''
if krig_type is 'Ord':
ord_krig=True
# Set the intervals
bp = bp[:]
bp.insert(0, np.min(data))
bp.append(np.max(data))
intervals = [[bp[i], bp[i+1]] for i in xrange(len(bp)-1)]
intervals[-1][1] = intervals[-1][1]+0.0001
# Make separation of the regime for each record
cond_map = np.zeros_like(data)
for st_i in xrange(len(stations)):
for n in xrange(len(data)):
for i in xrange(len(intervals)):
if data[n, st_i] >= min(intervals[i]) and \
data[n, st_i] < max(intervals[i]):
cond_map[n, st_i] = i
# Get distance between stations
dist_mat = np.array(dist.between(stations))
#initialisation of lists for each target
zz = np.zeros([len(data), len(targets)])
ssp = np.zeros([len(data), len(targets)])
for tarcoun in xrange(len(targets)):
#Select invidual target for itnerpolation
tar = targets[tarcoun]
##Select the closest NCS elements
#Calculate distance of all stations
das = np.array(dist.target([tar,], stations)).flatten()
#Select index of the closest stations
cs = list(das.argsort()[:ncs])
#Reduction of precipitation and sensor position matrices
red_data = data[:, cs]
red_dist = dist_mat[cs][:,cs]
red_cond_map = cond_map[:, cs]
red_xopt = x_opt_st[cs]
# Pre-cooked all zeros case
if ord_krig:
cov_mat_zeros = np.ones([ncs+1, ncs+1])
cov_mat_zeros[-1, -1] = 0
else:
cov_mat_zeros = np.ones([ncs, ncs])
for ii in xrange(ncs):
for jj in xrange(ncs):
# TODO include different variogram type where 0 is
cov_mat_zeros[ii, jj] = candidate_var[0](red_dist[ii, jj],
red_xopt[ii, 0])
if ord_krig:
cov_tar_zeros = np.ones([ncs+1, 1])
else:
cov_tar_zeros = np.ones([ncs, 1])
for ii in xrange(ncs):
cov_tar_zeros[ii, 0] = candidate_var[0](das[cs[ii]],
red_xopt[ii, 0])
# Inverse of extended covariance matrix
inv_cov_mat_zeros = np.linalg.inv(cov_mat_zeros)
# Kriging weights
w_vec = np.dot(inv_cov_mat_zeros, cov_tar_zeros)
# Interpolation variance and Kriging system solution
if ord_krig:
sp_zeros = (np.max(cov_mat_zeros)
- (np.sum(w_vec * cov_tar_zeros + w_vec[-1][0])))
else:
sp_zeros = (np.max(cov_mat_zeros)
- (np.dot(np.transpose(w_vec), cov_tar_zeros)[0][0]))
for t in xrange(len(data)):
# If there is some precipitation data
if np.max(red_data[t, :]) != 0:
## Here the interpolation is made for each of the time steps at
## each locatiom
#Make covariance matrix between stations in the neighborhoud (K)
if ord_krig:
cov_mat = np.ones([ncs+1, ncs+1])
cov_mat[-1, -1] = 0
else:
cov_mat = np.ones([ncs, ncs])
# Construct Covariance Matrix between stations
# for each precipitation event
for ii in xrange(ncs):
for jj in xrange(ncs):
# TODO include different variogram type where 0 is
cov_mat[ii, jj] = candidate_var[0](red_dist[ii, jj],
red_xopt[ii, int(red_cond_map[t, ii])])
# Fix maximum diagonal element to maximum of the variogram
# To force positive eigenvalues
for ii in xrange(ncs):
cov_mat[ii, ii] = np.max(cov_mat)
# Simmetrise using the average bi-directional covariance matrix
cov_mat = 0.5*(cov_mat + np.transpose(cov_mat))
# Construct covariance towards target
if ord_krig:
cov_tar = np.ones([ncs+1, 1])
else:
cov_tar = np.ones([ncs, 1])
for ii in xrange(ncs):
cov_tar[ii, 0] = candidate_var[0](das[cs[ii]],
red_xopt[ii, int(red_cond_map[t, ii])])
## Solve the Kriging system
# Invert the covariance matrix
inv_cov_mat = np.linalg.inv(cov_mat)
# Kriging weights
w_vec = np.dot(inv_cov_mat, cov_tar)
# Interpolation variance and Kriging system solution
if ord_krig:
z_temp = np.dot(np.transpose(w_vec[:-1]),
np.reshape(red_data[t, :], [-1,1]))[0][0]
#sp_temp = (np.max(cov_mat)
# - (np.sum(w_vec * cov_tar + w_vec[-1][0])))
sp_temp = (np.max(cov_mat)
- (np.sum(w_vec * cov_tar) + w_vec[-1][0]))
else:
z_temp = np.dot(np.transpose(w_vec),
np.reshape(red_data[t, :], [-1,1]))[0][0]
sp_temp = np.max(cov_mat) - (np.sum(w_vec * cov_tar))
# Appending of solutions
ssp[t, tarcoun] = sp_temp
zz[t, tarcoun] = z_temp
else:
ssp[t, tarcoun] = sp_zeros
zz[t, tarcoun] = 0
if verbose:
print ('Finished step {0}/{1} at {2}'.format(n, len(data),
ctime()))
return zz, ssp
def ns_kriging_d(data, stations, bp, x_opt_st, hyper_sv, mod_opt_st, targets,
candidate_var=[variogram_fit.spherical_sv,],
candidate_tag=['Spherical',], verbose=False, par_map=None,
ncs=3, only_par_map=False):
'''
t1_var : list
Parameters of the tier 1 variogram (variogram of the kriging
parameters) to be interpolated at each interval
Tihs uses a spatial distribution of the kriging parameters and conditions
'''
if ncs > len(stations):
print('Reduced number of minimum stations to total number of stations')
ncs = len(stations)
_bp = bp[:]
_bp.insert(0, np.min(data))
_bp.append(np.max(data))
intervals = [[_bp[i], _bp[i+1]] for i in xrange(len(_bp)-1)]
intervals[-1][1] = intervals[-1][1]+0.0001
# Get the paramter maps in each of the intervals
# Parameter maps have the shape of t targets, n samples
if par_map is None:
sill_map = np.zeros_like(data)
range_map = np.zeros_like(data)
nug_map = np.zeros_like(data)
for st_i in xrange(len(stations)):
for n in xrange(len(data)):
for i in xrange(len(intervals)):
if data[n, st_i] >= min(intervals[i]) and \
data[n, st_i] < max(intervals[i]):
sill_map[n, st_i] = x_opt_st[st_i, i, 0]
range_map[n, st_i] = x_opt_st[st_i, i, 1]
nug_map[n, st_i] = x_opt_st[st_i, i, 2]
# Make interpolation of the kriging parameters to the domain
hyper_cov_matrix = np.array([[variogram_fit.spherical_sv(kk, hyper_sv) for
kk in row_dist] for row_dist in
dist.between(stations)])
sill_int, _, _ = krig(MaxDist=5.0, targets=targets,
stations=stations, records=sill_map,
record_covariance_matrix=hyper_cov_matrix,
ModOpt=0, xopt=hyper_sv,
candidate_sv=[variogram_fit.spherical_sv,],
MinNumSt=ncs, normalisation=True,
krig_type='Ord')
range_int, _, _ = krig(MaxDist=5.0, targets=targets,
stations=stations, records=range_map,
record_covariance_matrix=hyper_cov_matrix,
ModOpt=0, xopt=hyper_sv,
candidate_sv=[variogram_fit.spherical_sv,],
MinNumSt=ncs, normalisation=True
, krig_type='Ord')
nug_int, _, _ = krig(MaxDist=5.0, targets=targets,
stations=stations, records=nug_map,
record_covariance_matrix=hyper_cov_matrix,
ModOpt=0, xopt=hyper_sv,
candidate_sv=[variogram_fit.spherical_sv,],
MinNumSt=ncs, normalisation=True,
krig_type='Ord')
par_map = [sill_int, range_int, nug_int]
if verbose: print ('Parameters interpolated in domain')
if only_par_map: return par_map
# do the interpolation
z_n = []
sp_n = []
for n in xrange(len(data)):
z_t = []
sp_t = []
for t in xrange(len(targets)):
# Get the variogram parameters for the interpolation centres
temp_var = [par_map[0][n, t], par_map[1][n, t], par_map[2][n, t], 0, 0]
# Do the covariance matrix
temp_cov_mat = np.array([[candidate_var[0](kk, temp_var) for
kk in row_dist] for row_dist in dist.between(stations)])
# Do the interpolation
z, sp, _ = krig(MaxDist=5.0, targets=[targets[t],],
stations=stations, records=[data[n, :],],
record_covariance_matrix=temp_cov_mat,
ModOpt=0, xopt=temp_var,
candidate_sv=candidate_var,
MinNumSt=ncs, krig_type='Ord',
normalisation=True)
# append results for each target
z = np.max([z[0][0], 0])
sp = np.max(sp[0], 0)
z_t.append(z)
sp_t.append(sp)
if verbose: print ('Finished step {0}/{1} at {2}'.format(n, len(data),
ctime()))
z_n.append(z_t)
sp_n.append(sp_t)
z_n = np.array(z_n)
sp_n = np.array(sp_n)
return z_n, sp_n, par_map
def ns_kriging_mm(data,
stations,
bp,
x_opt_st,
mod_opt_st,
targets,
candidate_var=[
variogram_fit.spherical_sv,
],
candidate_tag=[
'Spherical',
],
verbose=False,
ncs=3,
krig_type='Ord'):
'''
t1_var : list
Parameters of the tier 1 variogram (variogram of the kriging
parameters) to be interpolated at each interval
the method uses Ordinary Kriging using multi-precipitation model
'''
if krig_type is 'Ord':
ord_krig = True
# Set the intervals
bp = bp[:]
bp.insert(0, np.min(data))
bp.append(np.max(data))
intervals = [[bp[i], bp[i + 1]] for i in xrange(len(bp) - 1)]
intervals[-1][1] = intervals[-1][1] + 0.0001
# Make separation of the regime for each record
cond_map = np.zeros_like(data)
for st_i in xrange(len(stations)):
for n in xrange(len(data)):
for i in xrange(len(intervals)):
if data[n, st_i] >= min(intervals[i]) and \
data[n, st_i] < max(intervals[i]):
cond_map[n, st_i] = i
# Get distance between stations
dist_mat = np.array(dist.between(stations))
#initialisation of lists for each target
zz = np.zeros([len(data), len(targets)])
ssp = np.zeros([len(data), len(targets)])
for tarcoun in xrange(len(targets)):
#Select invidual target for itnerpolation
tar = targets[tarcoun]
##Select the closest NCS elements
#Calculate distance of all stations
das = np.array(dist.target([
tar,
], stations)).flatten()
#Select index of the closest stations
cs = list(das.argsort()[:ncs])
#Reduction of precipitation and sensor position matrices
red_data = data[:, cs]
red_dist = dist_mat[cs][:, cs]
red_cond_map = cond_map[:, cs]
red_xopt = x_opt_st[cs]
# Pre-cooked all zeros case
if ord_krig:
cov_mat_zeros = np.ones([ncs + 1, ncs + 1])
cov_mat_zeros[-1, -1] = 0
else:
cov_mat_zeros = np.ones([ncs, ncs])
for ii in xrange(ncs):
for jj in xrange(ncs):
# TODO include different variogram type where 0 is
cov_mat_zeros[ii, jj] = candidate_var[0](red_dist[ii, jj],
red_xopt[ii, 0])
if ord_krig:
cov_tar_zeros = np.ones([ncs + 1, 1])
else:
cov_tar_zeros = np.ones([ncs, 1])
for ii in xrange(ncs):
cov_tar_zeros[ii, 0] = candidate_var[0](das[cs[ii]], red_xopt[ii,
0])
# Inverse of extended covariance matrix
inv_cov_mat_zeros = np.linalg.inv(cov_mat_zeros)
# Kriging weights
w_vec = np.dot(inv_cov_mat_zeros, cov_tar_zeros)
# Interpolation variance and Kriging system solution
if ord_krig:
sp_zeros = (np.max(cov_mat_zeros) -
(np.sum(w_vec * cov_tar_zeros + w_vec[-1][0])))
else:
sp_zeros = (np.max(cov_mat_zeros) -
(np.dot(np.transpose(w_vec), cov_tar_zeros)[0][0]))
for t in xrange(len(data)):
# If there is some precipitation data
if np.max(red_data[t, :]) != 0:
## Here the interpolation is made for each of the time steps at
## each locatiom
#Make covariance matrix between stations in the neighborhoud (K)
if ord_krig:
cov_mat = np.ones([ncs + 1, ncs + 1])
cov_mat[-1, -1] = 0
else:
cov_mat = np.ones([ncs, ncs])
# Construct Covariance Matrix between stations
# for each precipitation event
for ii in xrange(ncs):
for jj in xrange(ncs):
# TODO include different variogram type where 0 is
cov_mat[ii, jj] = candidate_var[0](
red_dist[ii, jj], red_xopt[ii,
int(red_cond_map[t,
ii])])
# Fix maximum diagonal element to maximum of the variogram
# To force positive eigenvalues
for ii in xrange(ncs):
cov_mat[ii, ii] = np.max(cov_mat)
# Simmetrise using the average bi-directional covariance matrix
cov_mat = 0.5 * (cov_mat + np.transpose(cov_mat))
# Construct covariance towards target
if ord_krig:
cov_tar = np.ones([ncs + 1, 1])
else:
cov_tar = np.ones([ncs, 1])
for ii in xrange(ncs):
cov_tar[ii, 0] = candidate_var[0](
das[cs[ii]], red_xopt[ii, int(red_cond_map[t, ii])])
## Solve the Kriging system
# Invert the covariance matrix
inv_cov_mat = np.linalg.inv(cov_mat)
# Kriging weights
w_vec = np.dot(inv_cov_mat, cov_tar)
# Interpolation variance and Kriging system solution
if ord_krig:
z_temp = np.dot(np.transpose(w_vec[:-1]),
np.reshape(red_data[t, :], [-1, 1]))[0][0]
#sp_temp = (np.max(cov_mat)
# - (np.sum(w_vec * cov_tar + w_vec[-1][0])))
sp_temp = (np.max(cov_mat) -
(np.sum(w_vec * cov_tar) + w_vec[-1][0]))
else:
z_temp = np.dot(np.transpose(w_vec),
np.reshape(red_data[t, :], [-1, 1]))[0][0]
sp_temp = np.max(cov_mat) - (np.sum(w_vec * cov_tar))
# Appending of solutions
ssp[t, tarcoun] = sp_temp
zz[t, tarcoun] = z_temp
else:
ssp[t, tarcoun] = sp_zeros
zz[t, tarcoun] = 0
if verbose:
print('Finished step {0}/{1} at {2}'.format(
n, len(data), ctime()))
return zz, ssp
def ns_kriging_d(data,
stations,
bp,
x_opt_st,
hyper_sv,
mod_opt_st,
targets,
candidate_var=[
variogram_fit.spherical_sv,
],
candidate_tag=[
'Spherical',
],
verbose=False,
par_map=None,
ncs=3,
only_par_map=False):
'''
t1_var : list
Parameters of the tier 1 variogram (variogram of the kriging
parameters) to be interpolated at each interval
Tihs uses a spatial distribution of the kriging parameters and conditions
'''
if ncs > len(stations):
print('Reduced number of minimum stations to total number of stations')
ncs = len(stations)
_bp = bp[:]
_bp.insert(0, np.min(data))
_bp.append(np.max(data))
intervals = [[_bp[i], _bp[i + 1]] for i in xrange(len(_bp) - 1)]
intervals[-1][1] = intervals[-1][1] + 0.0001
# Get the paramter maps in each of the intervals
# Parameter maps have the shape of t targets, n samples
if par_map is None:
sill_map = np.zeros_like(data)
range_map = np.zeros_like(data)
nug_map = np.zeros_like(data)
for st_i in xrange(len(stations)):
for n in xrange(len(data)):
for i in xrange(len(intervals)):
if data[n, st_i] >= min(intervals[i]) and \
data[n, st_i] < max(intervals[i]):
sill_map[n, st_i] = x_opt_st[st_i, i, 0]
range_map[n, st_i] = x_opt_st[st_i, i, 1]
nug_map[n, st_i] = x_opt_st[st_i, i, 2]
# Make interpolation of the kriging parameters to the domain
hyper_cov_matrix = np.array(
[[variogram_fit.spherical_sv(kk, hyper_sv) for kk in row_dist]
for row_dist in dist.between(stations)])
sill_int, _, _ = krig(MaxDist=5.0,
targets=targets,
stations=stations,
records=sill_map,
record_covariance_matrix=hyper_cov_matrix,
ModOpt=0,
xopt=hyper_sv,
candidate_sv=[
variogram_fit.spherical_sv,
],
MinNumSt=ncs,
normalisation=True,
krig_type='Ord')
range_int, _, _ = krig(MaxDist=5.0,
targets=targets,
stations=stations,
records=range_map,
record_covariance_matrix=hyper_cov_matrix,
ModOpt=0,
xopt=hyper_sv,
candidate_sv=[
variogram_fit.spherical_sv,
],
MinNumSt=ncs,
normalisation=True,
krig_type='Ord')
nug_int, _, _ = krig(MaxDist=5.0,
targets=targets,
stations=stations,
records=nug_map,
record_covariance_matrix=hyper_cov_matrix,
ModOpt=0,
xopt=hyper_sv,
candidate_sv=[
variogram_fit.spherical_sv,
],
MinNumSt=ncs,
normalisation=True,
krig_type='Ord')
par_map = [sill_int, range_int, nug_int]
if verbose: print('Parameters interpolated in domain')
if only_par_map: return par_map
# do the interpolation
z_n = []
sp_n = []
for n in xrange(len(data)):
z_t = []
sp_t = []
for t in xrange(len(targets)):
# Get the variogram parameters for the interpolation centres
temp_var = [
par_map[0][n, t], par_map[1][n, t], par_map[2][n, t], 0, 0
]
# Do the covariance matrix
temp_cov_mat = np.array(
[[candidate_var[0](kk, temp_var) for kk in row_dist]
for row_dist in dist.between(stations)])
# Do the interpolation
z, sp, _ = krig(MaxDist=5.0,
targets=[
targets[t],
],
stations=stations,
records=[
data[n, :],
],
record_covariance_matrix=temp_cov_mat,
ModOpt=0,
xopt=temp_var,
candidate_sv=candidate_var,
MinNumSt=ncs,
krig_type='Ord',
normalisation=True)
# append results for each target
z = np.max([z[0][0], 0])
sp = np.max(sp[0], 0)
z_t.append(z)
sp_t.append(sp)
if verbose:
print('Finished step {0}/{1} at {2}'.format(n, len(data), ctime()))
z_n.append(z_t)
sp_n.append(sp_t)
z_n = np.array(z_n)
sp_n = np.array(sp_n)
return z_n, sp_n, par_map
