def interpolate_nearest(x, y, z, x_val, y_val, z_val):
"""Neirest neighbour interpolation.
Parameters
----------
x : np.ndarray
x-faces or x-edges of a mesh
y : np.ndarray
y-faces or y-edges of a mesh
z : np.ndarray
z-faces or z-edges of a mesh
x_val : np.ndarray
curl values or electric field values in the x-direction
y_val : np.ndarray
curl values or electric field values in the y-direction
z_val : np.ndarray
curl values or electric field values in the z-direction
Returns
-------
scipy.interpolate.ndgriddata.NearestNDInterpolator
a neirest neighbour interpolation object
"""
x_interpolated = NearestNDInterpolator(x, x_val)
y_interpolated = NearestNDInterpolator(y, y_val)
z_interpolated = NearestNDInterpolator(z, z_val)
return x_interpolated, y_interpolated, z_interpolated
def fit(self):
"""
Defines the interpolation functions from the raw data.
"""
# Ignore a1, a2=1.0 values if included
shortdata = self.data[~(np.isclose(self.data.a1, 1.0) | np.isclose(self.data.a2, 1.0))]
# Create supercells of values
a1 = shortdata.a1
a2 = shortdata.a2
a1 = np.concatenate([a1-1, a1-1, a1-1, a1, a1, a1, a1+1, a1+1, a1+1])
a2 = np.concatenate([a2-1, a2, a2+1, a2-1, a2, a2+1, a2-1, a2, a2+1])
# Find values in 0-1 cell +- one point
ua1 = np.unique(a1)
ua2 = np.unique(a2)
a1min = ua1[np.where(np.isclose(ua1, 0.0))[0][0] - 1] - 1e-8
a1max = ua1[np.where(np.isclose(ua1, 1.0))[0][-1] + 1] + 1e-8
a2min = ua2[np.where(np.isclose(ua2, 0.0))[0][0] - 1] - 1e-8
a2max = ua2[np.where(np.isclose(ua2, 1.0))[0][-1] + 1] + 1e-8
ix = np.where((a1 >= a1min) & (a1 <= a1max) & (a2 >= a2min) & (a2 <= a2max))
# Fit energy
E_gsf = np.concatenate([shortdata.E_gsf] * 9)
self.__E_gsf_fit = Rbf(a1[ix], a2[ix], E_gsf[ix])
self.__E_gsf_nearest = NearestNDInterpolator(np.array([a1[ix], a2[ix]]).T, E_gsf[ix])
# Fit delta
if 'delta' in self.data:
delta = np.concatenate([shortdata.delta] * 9)
self.__delta_fit = Rbf(a1[ix], a2[ix], delta[ix])
self.__delta_nearest = NearestNDInterpolator(np.array([a1[ix], a2[ix]]).T, delta[ix])
def test_nearest_options():
# smoke test that NearestNDInterpolator accept cKDTree options
npts, nd = 4, 3
x = np.arange(npts * nd).reshape((npts, nd))
y = np.arange(npts)
nndi = NearestNDInterpolator(x, y)
opts = {'balanced_tree': False, 'compact_nodes': False}
nndi_o = NearestNDInterpolator(x, y, tree_options=opts)
assert_allclose(nndi(x), nndi_o(x), atol=1e-14)
def test_nearest_list_argument():
nd = np.array([[0, 0, 0, 0, 1, 0, 1], [0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 1, 1, 2]])
d = nd[:, 3:]
# z is np.array
NI = NearestNDInterpolator((d[0], d[1]), d[2])
assert_array_equal(NI([0.1, 0.9], [0.1, 0.9]), [0, 2])
# z is list
NI = NearestNDInterpolator((d[0], d[1]), list(d[2]))
assert_array_equal(NI([0.1, 0.9], [0.1, 0.9]), [0, 2])
def get_shifter_from_centers(centers5,
locs,
maxshift=8,
plot=True,
nearest=True):
corrgrid = deepcopy(centers5)
a = np.where(corrgrid > maxshift)
corrgrid[a] = maxshift
b = np.where(corrgrid < -maxshift)
corrgrid[b] = -maxshift
corrgrid[np.isnan(corrgrid)] = 0
Npos = corrgrid.shape[0]
coords = np.zeros([Npos * Npos, 4])
nn = 0
if plot:
fig = plt.figure(figsize=(12, 8))
ax = fig.gca()
for xx in range(Npos):
for yy in range(Npos):
coords[nn, :] = [
locs[xx], locs[yy], corrgrid[xx, yy, 0], corrgrid[xx, yy, 1]
]
nn += 1
if plot:
plt.plot([locs[xx], centers5[xx, yy, 0] + locs[xx]],
[locs[yy], centers5[xx, yy, 1] + locs[yy]], 'c')
plt.plot(centers5[xx, yy, 0] + locs[xx],
centers5[xx, yy, 1] + locs[yy], 'rx')
if plot:
plt.axis('equal')
ax.set_xticks(locs)
ax.set_yticks(locs)
ax.grid()
ax.grid(linestyle='-', linewidth='0.5', color='cyan')
plt.figure()
plt.imshow(corrgrid[:, :, 0], vmin=-maxshift, vmax=maxshift)
plt.colorbar()
if nearest:
xcorrec = NearestNDInterpolator(coords[:, 0:2], coords[:, 2])
ycorrec = NearestNDInterpolator(coords[:, 0:2], coords[:, 3])
else:
xcorrec = LinearNDInterpolator(coords[:, 0:2], coords[:, 2])
ycorrec = LinearNDInterpolator(coords[:, 0:2], coords[:, 3])
return xcorrec, ycorrec
def fill_missing(mask, x, y, u, v):
"""Fill missing value with by interpolating the values from nearest
neighbours"""
# Construct the interpolators from the boundary values surrounding the
# missing values.
boundaries = find_boundaries(u.mask, mode='outer')
points = np.stack((y[boundaries], x[boundaries])).T
ip_u = NearestNDInterpolator(points, u[boundaries], rescale=False)
ip_v = NearestNDInterpolator(points, v[boundaries], rescale=False)
# Interpolate only missing values.
missing = (y[mask], x[mask])
u[mask] = ip_u(missing)
v[mask] = ip_v(missing)
def load_iemre():
"""Use IEM Reanalysis for non-precip data
24km product is smoothed down to the 0.01 degree grid
"""
printt("load_iemre() called")
xaxis = np.arange(MYWEST, MYEAST, 0.01)
yaxis = np.arange(MYSOUTH, MYNORTH, 0.01)
xi, yi = np.meshgrid(xaxis, yaxis)
fn = iemre.get_daily_ncname(VALID.year)
if not os.path.isfile(fn):
printt("Missing %s for load_solar, aborting" % (fn, ))
sys.exit()
with ncopen(fn) as nc:
offset = iemre.daily_offset(VALID)
lats = nc.variables["lat"][:]
lons = nc.variables["lon"][:]
lons, lats = np.meshgrid(lons, lats)
# Storage is W m-2, we want langleys per day
data = nc.variables["rsds"][offset, :, :] * 86400.0 / 1000000.0 * 23.9
# Default to a value of 300 when this data is missing, for some reason
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
SOLAR[:] = iemre_bounds_check("rsds", nn(xi, yi), 0, 1000)
data = temperature(nc.variables["high_tmpk"][offset, :, :],
"K").value("C")
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
HIGH_TEMP[:] = iemre_bounds_check("high_tmpk", nn(xi, yi), -60, 60)
data = temperature(nc.variables["low_tmpk"][offset, :, :],
"K").value("C")
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
LOW_TEMP[:] = iemre_bounds_check("low_tmpk", nn(xi, yi), -60, 60)
data = temperature(nc.variables["avg_dwpk"][offset, :, :],
"K").value("C")
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
DEWPOINT[:] = iemre_bounds_check("avg_dwpk", nn(xi, yi), -60, 60)
data = nc.variables["wind_speed"][offset, :, :]
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
WIND[:] = iemre_bounds_check("wind_speed", nn(xi, yi), 0, 30)
printt("load_iemre() finished")
def load_iemre():
"""Use IEM Reanalysis for non-precip data
24km product is smoothed down to the 0.01 degree grid
"""
printt("load_iemre() called")
xaxis = np.arange(WEST, EAST, 0.01)
yaxis = np.arange(SOUTH, NORTH, 0.01)
xi, yi = np.meshgrid(xaxis, yaxis)
fn = "/mesonet/data/iemre/%s_mw_daily.nc" % (VALID.year,)
if not os.path.isfile(fn):
printt("Missing %s for load_solar, aborting" % (fn,))
sys.exit()
nc = netCDF4.Dataset(fn, 'r')
offset = iemre.daily_offset(VALID)
lats = nc.variables['lat'][:]
lons = nc.variables['lon'][:]
lons, lats = np.meshgrid(lons, lats)
# Storage is W m-2, we want langleys per day
data = nc.variables['rsds'][offset, :, :] * 86400. / 1000000. * 23.9
# Default to a value of 300 when this data is missing, for some reason
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
SOLAR[:] = iemre_bounds_check('rsds', nn(xi, yi), 0, 1000)
data = temperature(nc.variables['high_tmpk'][offset, :, :], 'K').value('C')
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
HIGH_TEMP[:] = iemre_bounds_check('high_tmpk', nn(xi, yi), -60, 60)
data = temperature(nc.variables['low_tmpk'][offset, :, :], 'K').value('C')
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
LOW_TEMP[:] = iemre_bounds_check('low_tmpk', nn(xi, yi), -60, 60)
data = temperature(nc.variables['avg_dwpk'][offset, :, :], 'K').value('C')
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
DEWPOINT[:] = iemre_bounds_check('avg_dwpk', nn(xi, yi), -60, 60)
data = nc.variables['wind_speed'][offset, :, :]
nn = NearestNDInterpolator((np.ravel(lons), np.ravel(lats)),
np.ravel(data))
WIND[:] = iemre_bounds_check('wind_speed', nn(xi, yi), 0, 30)
nc.close()
printt("load_iemre() finished")
def perform_upsampling_labels(self,image, labels):
if (self.paras['verbose']>0): print ("Perform upsampling", flush=True)
step = self.paras['step']
shape_image = image.shape
shape_labels = labels.shape
x_index = np.arange(shape_image[0]) - self.paras['window_x'] - self.paras['patch_x']
y_index = np.arange(shape_image[1]) - self.paras['window_y'] - self.paras['patch_y']
x_grid, y_grid = np.meshgrid(x_index, y_index,indexing='ij')
x_grid = (x_grid / step).flatten()
y_grid = (y_grid / step).flatten()
coords = np.vstack((x_grid, y_grid)).T
if self.paras['soft_segmentation'] is False:
x_labels, y_labels = np.meshgrid(np.arange(shape_labels[0]),np.arange(shape_labels[1]),indexing='ij')
x_labels = x_labels.flatten()
y_labels = y_labels.flatten()
input_coords = np.vstack([x_labels, y_labels]).T
interpolator = NearestNDInterpolator(input_coords, labels.flatten())
labels_up = interpolator(coords)
labels_up = np.reshape(labels_up, shape_image)
#labels_up = np.round(labels_up).astype(np.int32) % self.paras['n_patterns']
else:
labels_up = map_coordinates(labels, coords,mode='nearest')
labels_up = np.reshape(labels_up, (shape_image[0], shape_image[1]))
labels_up = np.clip(labels_up,0.,self.paras['n_patterns']-1.)
if self.paras['sort_labels_by_pattern_size'] is True:
labels_up = self.sort_labels_by_pattern_size(labels_up)
return labels_up
def nearest_neighbor_advection(im, flow):
"""
Parameters
----------
im : np.ndarray
Shape: (batch_size, C, H, W)
flow : np.ndarray
Shape: (batch_size, 2, H, W)
Returns
-------
new_im : nd.NDArray
"""
predict_frame = np.empty(im.shape, dtype=im.dtype)
batch_size, channel_num, height, width = im.shape
assert channel_num == 1
grid_x, grid_y = np.meshgrid(np.arange(width), np.arange(height))
interp_grid = np.hstack([grid_x.reshape((-1, 1)), grid_y.reshape((-1, 1))])
for i in range(batch_size):
flow_interpolator = NearestNDInterpolator(interp_grid, im[i].ravel())
predict_grid = interp_grid + np.hstack(
[flow[i][0].reshape((-1, 1)), flow[i][1].reshape((-1, 1))])
predict_frame[i, 0, ...] = flow_interpolator(predict_grid).reshape(
(height, width))
return predict_frame
def do_coop(ts):
"""Use COOP solar radiation data"""
pgconn = get_dbconn('coop', user='******')
cursor = pgconn.cursor()
cursor.execute("""SELECT ST_x(geom), ST_y(geom),
coalesce(narr_srad, merra_srad) from alldata a JOIN stations t
ON (a.station = t.id) WHERE
day = %s and t.network ~* 'CLIMATE' and substr(id, 3, 1) != 'C'
and substr(id, 3, 4) != '0000'
""", (ts.strftime("%Y-%m-%d"), ))
lons = []
lats = []
vals = []
for row in cursor:
if row[2] is None or row[2] < 0:
continue
lons.append(row[0])
lats.append(row[1])
vals.append(row[2])
nn = NearestNDInterpolator((np.array(lons), np.array(lats)),
np.array(vals))
xi, yi = np.meshgrid(iemre.XAXIS, iemre.YAXIS)
ds = iemre.get_grids(ts.date(), varnames='rsds')
# Convert MJ/d to Wm2
ds['rsds'].values = nn(xi, yi) * 1000000. / 86400.
iemre.set_grids(ts.date(), ds)
subprocess.call(
"python db_to_netcdf.py %s" % (ts.strftime("%Y %m %d"), ),
shell=True)
def _build_vertex_values(self, items, area_func, value_func):
"""
Interpolate vertice with known altitudes to get altitudes for the remaining ones.
"""
vertex_values = np.empty(self.vertices.shape[:1], dtype=np.int32)
if not vertex_values.size:
return vertex_values
vertex_value_mask = np.full(self.vertices.shape[:1], fill_value=False, dtype=np.bool)
for item in items:
faces = area_func(item).faces
if not faces:
continue
i_vertices = np.unique(self.faces[np.array(tuple(chain(*faces)))].flatten())
vertex_values[i_vertices] = value_func(item, i_vertices)
vertex_value_mask[i_vertices] = True
if np.any(vertex_value_mask) and not np.all(vertex_value_mask):
interpolate = NearestNDInterpolator(self.vertices[vertex_value_mask],
vertex_values[vertex_value_mask])
vertex_values[np.logical_not(vertex_value_mask)] = interpolate(
*np.transpose(self.vertices[np.logical_not(vertex_value_mask)])
)
return vertex_values
def interpolate_timeseries(project, data):
im_soft = np.load(os.path.join(ecm.INPUT_DIR, 'im_soft.npz'))['arr_0']
x_len, y_len = im_soft.shape
net = project.network
res_Ts = net.throats('spm_resistor')
sorted_res_Ts = net['throat.spm_resistor_order'][res_Ts].argsort()
res_pores = net['pore.coords'][net['throat.conns'][res_Ts[sorted_res_Ts]]]
res_Ts_coords = np.mean(res_pores, axis=1)
x = res_Ts_coords[:, 0]
y = res_Ts_coords[:, 1]
all_x = []
all_y = []
all_t = []
all_data = []
for t in range(data.shape[0]):
all_x = all_x + x.tolist()
all_y = all_y + y.tolist()
all_t = all_t + (np.ones(len(x)) * t).tolist()
all_data = all_data + data[t, :].tolist()
all_x = np.asarray(all_x)
all_y = np.asarray(all_y)
all_t = np.asarray(all_t)
all_data = np.asarray(all_data)
points = np.vstack((all_x, all_y, all_t)).T
myInterpolator = NearestNDInterpolator(points, all_data)
return myInterpolator
def interpolate_dataset(
points: NDArray[(2, Any), float],
values: NDArray[(Any, Any), float],
target_points: NDArray[(2, Any), float],
method: str,
) -> NDArray[(Any,), float]:
"""Generates standard climpyrical xarray Dataset.
------------------------------
Args:
points (np.ndarray): ordered pairs of coordinates
from current grid
values (np.ndarray): field values at points
target_points (np.ndarray): ordered pairs of coordinates
from target grid
method (str): desired method - can be either 'linear' or
'nearest'
Returns:
(np.ndarray): newly predicted values at target points
"""
if method != "linear" and method != "nearest":
raise ValueError("Method must be linear or nearest.")
method_dict = {
"linear": LinearNDInterpolator(points, values),
"nearest": NearestNDInterpolator(points, values),
}
f = method_dict[method]
return f(target_points).T
def create_climate_geoGrid_interpolator_from_json_file(
path_to_latlon_to_rowcol_file, worldGeodeticSys84, geoTargetGrid,
cdict):
"create interpolator from json list of lat/lon to row/col mappings"
with open(path_to_latlon_to_rowcol_file) as _:
points = []
values = []
transformer = Transformer.from_crs(worldGeodeticSys84,
geoTargetGrid,
always_xy=True)
for latlon, rowcol in json.load(_):
row, col = rowcol
clat, clon = latlon
try:
cr_geoTargetGrid, ch_geoTargetGrid = transformer.transform(
clon, clat)
cdict[(row, col)] = (round(clat, 4), round(clon, 4))
points.append([cr_geoTargetGrid, ch_geoTargetGrid])
values.append((row, col))
#print "row:", row, "col:", col, "clat:", clat, "clon:", clon, "h:", h, "r:", r, "val:", values[i]
except:
continue
return NearestNDInterpolator(np.array(points), np.array(values))
def __init__(self, scenario: model.Scenario):
"""Initialize the model."""
super().__init__(scenario)
s = self._scenario
flag_rs = flag_ss = flag_ns = 0
if s.mechanism == 'SS':
flag_ss = 1
elif s.mechanism == 'NS':
flag_ns = 1
elif s.mechanism == 'RS':
flag_rs = 1
event = (s.mag, s.depth_hyp, flag_rs, flag_ss, flag_ns, s.dist_jb,
s.v_s30)
global INTERPOLATOR
if INTERPOLATOR is None:
with np.load(fname_data) as data:
INTERPOLATOR = NearestNDInterpolator(data['events'],
data['predictions'])
prediction = INTERPOLATOR(event)
self._ln_resp = prediction[0::2]
self._ln_std = np.sqrt(prediction[1::2])
def make_nearest_interpolator_unstructured(field, grid=None):
'''Make a nearest interpolator for an unstructured grid.
Parameters
----------
field : Field or array_like
The field to interpolate.
grid : Grid or None
The grid of the field. If it is given, the grid of `field` is replaced by this grid.
Returns
-------
Field generator
The interpolator as a Field generator. The grid on which this field generator will be evaluated does
not need to have any structure.
'''
if grid is None:
grid = field.grid
else:
field = Field(field, grid)
interp = NearestNDInterpolator(grid.points, field, fill_value)
def interpolator(evaluated_grid):
res = interp(grid.points)
return Field(res, evaluated_grid)
return interpolator
def copy_to_iemre(valid):
"""verbatim copy over to IEMRE."""
tidx = iemre.hourly_offset(valid)
nc = ncopen(("/mesonet/data/stage4/%s_stage4_hourly.nc") % (valid.year, ),
'a',
timeout=300)
lats = nc.variables['lat'][:]
lons = nc.variables['lon'][:]
val = nc.variables['p01m'][tidx]
nc.close()
# Our data is 4km, iemre is 0.125deg, so we stride some to cut down on mem
stride = slice(None, None, 3)
lats = np.ravel(lats[stride, stride])
lons = np.ravel(lons[stride, stride])
vals = np.ravel(val[stride, stride])
nn = NearestNDInterpolator((lons, lats), vals)
xi, yi = np.meshgrid(iemre.XAXIS, iemre.YAXIS)
res = nn(xi, yi)
# Lets clip bad data
# 10 inches per hour is bad data
res = np.where(np.logical_or(res < 0, res > 250), 0., res)
# Open up our RE file
nc = ncopen(iemre.get_hourly_ncname(valid.year), 'a', timeout=300)
nc.variables["p01m"][tidx, :, :] = res
LOG.debug("wrote data to hourly IEMRE min: %.2f avg: %.2f max: %.2f",
np.min(res), np.mean(res), np.max(res))
nc.close()
def merge(valid):
"""
Process an hour's worth of stage4 data into the hourly RE
"""
nc = netCDF4.Dataset(
("/mesonet/data/stage4/%s_stage4_hourly.nc") % (valid.year, ), 'r')
tidx = iemre.hourly_offset(valid)
val = nc.variables['p01m'][tidx, :, :]
# print("stage4 mean: %.2f max: %.2f" % (np.mean(val), np.max(val)))
lats = nc.variables['lat'][:]
lons = nc.variables['lon'][:]
# Rough subsample, since the whole enchillata is too much
lats = np.ravel(lats[200:-100:5, 300:900:5])
lons = np.ravel(lons[200:-100:5, 300:900:5])
vals = np.ravel(val[200:-100:5, 300:900:5])
nn = NearestNDInterpolator((lons, lats), vals)
xi, yi = np.meshgrid(iemre.XAXIS, iemre.YAXIS)
res = nn(xi, yi)
# Lets clip bad data
# 10 inches per hour is bad data
res = np.where(np.logical_or(res < 0, res > 250), 0., res)
# print("Resulting mean: %.2f max: %.2f" % (np.mean(res), np.max(res)))
# Open up our RE file
nc = netCDF4.Dataset(
"/mesonet/data/iemre/%s_mw_hourly.nc" % (valid.year, ), 'a')
nc.variables["p01m"][tidx, :, :] = res
# print(("Readback mean: %.2f max: %.2f"
# ) % (np.mean(nc.variables["p01m"][tidx, :, :]),
# np.max(nc.variables["p01m"][tidx, :, :])))
nc.close()
def do_coop(ts):
"""Use COOP solar radiation data"""
pgconn = psycopg2.connect(database='coop', host='iemdb', user='******')
cursor = pgconn.cursor()
cursor.execute(
"""SELECT ST_x(geom), ST_y(geom),
coalesce(narr_srad, merra_srad) from alldata a JOIN stations t
ON (a.station = t.id) WHERE
day = %s and t.network ~* 'CLIMATE' and substr(id, 3, 1) != 'C'
and substr(id, 3, 4) != '0000'
""", (ts.strftime("%Y-%m-%d"), ))
lons = []
lats = []
vals = []
for row in cursor:
if row[2] is None or row[2] < 0:
continue
lons.append(row[0])
lats.append(row[1])
vals.append(row[2])
nn = NearestNDInterpolator((np.array(lons), np.array(lats)),
np.array(vals))
xi, yi = np.meshgrid(iemre.XAXIS, iemre.YAXIS)
nc = netCDF4.Dataset("/mesonet/data/iemre/%s_mw_daily.nc" % (ts.year, ),
'a')
offset = iemre.daily_offset(ts)
# Data above is MJ / d / m-2, we want W / m-2
nc.variables['rsds'][offset, :, :] = nn(xi, yi) * 1000000. / 86400.
nc.close()
def checklabels(self,inlabels,**kwargs): # a function that allows the user to determine the nearest C3K labels to array on input labels # useful to run before actually selecting spectra labels = [] for li in inlabels: # select the C3K spectra at that [Fe/H] and [alpha/Fe] teff_i = li[0] logg_i = li[1] FeH_i = li[2] alpha_i = li[3] # find nearest value to FeH and aFe FeH_i = self.FeHarr[np.argmin(np.abs(self.FeHarr-FeH_i))] alpha_i = self.alphaarr[np.argmin(np.abs(self.alphaarr-alpha_i))] # select the C3K spectra for these alpha and FeH C3K_i = self.C3K[alpha_i][FeH_i] # create array of all labels in specific C3K file C3Kpars = np.array(C3K_i['parameters']) # do a nearest neighbor interpolation on Teff and log(g) in the C3K grid C3KNN = NearestNDInterpolator( np.array([C3Kpars['logt'],C3Kpars['logg']]).T,range(0,len(C3Kpars)) )((teff_i,logg_i)) # determine the labels for the selected C3K spectrum label_i = list(C3Kpars[C3KNN]) labels.append(label_i) return np.array(labels)
def __init__(self, source, target, parameters):
import pickle
ModularConnectorFunction.__init__(self, source, target, parameters)
t_size = target.size_in_degrees()
f = open(self.parameters.or_map_location, 'r')
mmap = pickle.load(f)
coords_x = numpy.linspace(-t_size[0] / 2.0, t_size[0] / 2.0,
numpy.shape(mmap)[0])
coords_y = numpy.linspace(-t_size[1] / 2.0, t_size[1] / 2.0,
numpy.shape(mmap)[1])
X, Y = numpy.meshgrid(coords_x, coords_y)
self.mmap = NearestNDInterpolator(zip(X.flatten(), Y.flatten()),
mmap.flatten())
self.or_source = self.mmap(
numpy.transpose(
numpy.array([
self.source.pop.positions[0], self.source.pop.positions[1]
]))) * numpy.pi
for (index, neuron2) in enumerate(target.pop.all()):
val_target = self.mmap(self.target.pop.positions[0][index],
self.target.pop.positions[1][index])
self.target.add_neuron_annotation(index,
'ORMapOrientation',
val_target * numpy.pi,
protected=False)
def generic_gridder(nc, cursor, idx):
"""
Generic gridding algorithm for easy variables
"""
lats = []
lons = []
vals = []
for row in cursor:
if row[idx] is not None and row["station"] in NT.sts:
lats.append(NT.sts[row["station"]]["lat"])
lons.append(NT.sts[row["station"]]["lon"])
vals.append(row[idx])
if len(vals) < 4:
print(
("Only %s observations found for %s, won't grid")
% (len(vals), idx)
)
return None
xi, yi = np.meshgrid(nc.variables["lon"][:], nc.variables["lat"][:])
nn = NearestNDInterpolator((lons, lats), np.array(vals))
grid = nn(xi, yi)
print(
("%s %s %.3f %.3f")
% (cursor.rowcount, idx, np.max(grid), np.min(grid))
)
if grid is not None:
return grid
return None
def merge(nc, valid, gribname, vname):
"""Merge in the grib data"""
fn = valid.strftime(("/mesonet/ARCHIVE/data/%Y/%m/%d/model/cfs/%H/" +
gribname + ".01.%Y%m%d%H.daily.grib2"))
if not os.path.isfile(fn):
print("cfs2iemre missing %s, abort" % (fn, ))
sys.exit()
grbs = pygrib.open(fn)
lats = None
lons = None
xi, yi = np.meshgrid(iemre.XAXIS, iemre.YAXIS)
for grib in tqdm(grbs,
total=grbs.messages,
desc=vname,
disable=not sys.stdout.isatty()):
ftime = valid + datetime.timedelta(hours=grib.forecastTime)
# move us safely back to get into the proper date
cst = ftime - datetime.timedelta(hours=7)
if cst.year != valid.year:
continue
if lats is None:
lats, lons = grib.latlons()
vals = grib.values
nn = NearestNDInterpolator((lons.flat, lats.flat), vals.flat)
vals = nn(xi, yi)
tstep = iemre.daily_offset(cst.date())
current = nc.variables[vname][tstep, :, :]
if current.mask.all():
current[:, :] = DEFAULTS[vname]
nc.variables[vname][tstep, :, :] = AGGFUNC[vname](current, vals)
def test_contour_linear_ring():
"""Test contourf with a section that only has 3 points."""
ax = plt.axes([0.01, 0.05, 0.898, 0.85],
projection=ccrs.Mercator(),
aspect='equal')
ax.set_extent([-99.6, -89.0, 39.8, 45.5])
xbnds = ax.get_xlim()
ybnds = ax.get_ylim()
ll = ccrs.Geodetic().transform_point(xbnds[0], ybnds[0], ax.projection)
ul = ccrs.Geodetic().transform_point(xbnds[0], ybnds[1], ax.projection)
ur = ccrs.Geodetic().transform_point(xbnds[1], ybnds[1], ax.projection)
lr = ccrs.Geodetic().transform_point(xbnds[1], ybnds[0], ax.projection)
xi = np.linspace(min(ll[0], ul[0]), max(lr[0], ur[0]), 100)
yi = np.linspace(min(ll[1], ul[1]), max(ul[1], ur[1]), 100)
xi, yi = np.meshgrid(xi, yi)
nn = NearestNDInterpolator((np.arange(-94, -85), np.arange(36, 45)),
np.arange(9))
vals = nn(xi, yi)
lons = xi
lats = yi
window = np.ones((6, 6))
vals = convolve2d(vals,
window / window.sum(),
mode='same',
boundary='symm')
ax.contourf(lons, lats, vals, np.arange(9), transform=ccrs.PlateCarree())
plt.draw()
def create_ascii_grid_interpolator(arr, meta, ignore_nodata=True):
"read an ascii grid into a map, without the no-data values"
rows, cols = arr.shape
cellsize = int(meta["cellsize"])
xll = int(meta["xllcorner"])
yll = int(meta["yllcorner"])
nodata_value = meta["nodata_value"]
xll_center = xll + cellsize // 2
yll_center = yll + cellsize // 2
yul_center = yll_center + (rows - 1)*cellsize
points = []
values = []
for row in range(rows):
for col in range(cols):
value = arr[row, col]
if ignore_nodata and value == nodata_value:
continue
r = xll_center + col * cellsize
h = yul_center - row * cellsize
points.append([r, h])
values.append(value)
return NearestNDInterpolator(np.array(points), np.array(values))
def try_merra(ts):
"""Attempt to use MERRA data."""
# Our files are UTC date based :/
ncfn1 = ts.strftime("/mesonet/merra2/%Y/%Y%m%d.nc")
ncfn2 = (
ts + datetime.timedelta(days=1)
).strftime("/mesonet/merra2/%Y/%Y%m%d.nc")
if not os.path.isfile(ncfn1) or not os.path.isfile(ncfn2):
return False
with ncopen(ncfn1) as nc:
# Total up from 6z to end of file for today
total = np.sum(nc.variables['SWGDN'][5:, :, :], axis=0)
with ncopen(ncfn2) as nc:
lat1d = nc.variables['lat'][:]
lon1d = nc.variables['lon'][:]
# Total up to 6z
total += np.sum(nc.variables['SWGDN'][:6, :, :], axis=0)
# We wanna store as W m-2, so we just average out the data by hour
total = total / 24.0
lons, lats = np.meshgrid(lon1d, lat1d)
nn = NearestNDInterpolator(
(lons.flatten(), lats.flatten()), total.flatten()
)
xi, yi = np.meshgrid(iemre.XAXIS, iemre.YAXIS)
ds = iemre.get_grids(ts.date(), varnames='rsds')
ds['rsds'].values = nn(xi, yi)
iemre.set_grids(ts.date(), ds)
subprocess.call(
"python db_to_netcdf.py %s" % (ts.strftime("%Y %m %d"), ),
shell=True)
return True
def generic_gridder(df, idx):
"""
Generic gridding algorithm for easy variables
"""
window = 2.0
f1 = df[df[idx].notnull()]
for lat in np.arange(iemre.SOUTH, iemre.NORTH, window):
for lon in np.arange(iemre.WEST, iemre.EAST, window):
(west, east, south, north) = (lon, lon + window, lat, lat + window)
box = f1[(f1['lat'] >= south) & (f1['lat'] < north) &
(f1['lon'] >= west) & (f1['lon'] < east)]
if len(box.index) < 4:
continue
z = np.abs(zscore(box[idx]))
# Compute where the standard dev is +/- 2std
bad = box[z > 1.5]
df.loc[bad.index, idx] = np.nan
# for _, row in bad.iterrows():
# print _, idx, row['station'], row['name'], row[idx]
good = df[df[idx].notnull()]
nn = NearestNDInterpolator((np.array(good['lon']), np.array(good['lat'])),
np.array(good[idx]))
xi, yi = np.meshgrid(iemre.XAXIS, iemre.YAXIS)
grid = nn(xi, yi)
return grid
def InterpolateOntoCartesian(X, Y, Z, RHO, newX, newY, newZ):
from joblib import Parallel, delayed
from scipy.spatial import Delaunay
from scipy.interpolate import NearestNDInterpolator
radialCoords = np.stack((X, Y, Z)).T
newCoords = np.stack((newX.ravel(), newY.ravel(), newZ.ravel())).T
newCoordsChunks = np.array_split(newCoords,
indices_or_sections=100,
axis=0)
st.write('Preparing interpolation grid...')
tri = Delaunay(radialCoords,
) #qhull_options='Qbb Qc Qz Q0 Q3 Q5 Q8 C0 C-0')
interpolator = NearestNDInterpolator(tri, RHO.ravel())
st.write('Interpolating...')
def DoOneChunk(i, chunk):
print(f'Chunk {i} of {len(newCoordsChunks)}')
RHOinterpolated = interpolator(chunk)
RHOinterpolated = np.nan_to_num(RHOinterpolated)
# Zero out cartesian coordinates that are outside the original radius.
dist = np.sqrt(chunk[:, 0]**2 + chunk[:, 1]**2 + chunk[:, 2]**2)
RHOinterpolated[dist > np.max(X)] = 0
return RHOinterpolated
results = Parallel(n_jobs=5, verbose=100, pre_dispatch=10)(
delayed(DoOneChunk)(i, chunk)
for i, chunk in enumerate(newCoordsChunks))
return np.concatenate(results)
def area(base_folder):
"""
Parameters
----------
base_folder : TYPE
Top level folder of the RSM Suite
Returns
-------
Projected Area
"""
values=[]
areafile = (base_folder+os.sep+"Outputs/Projected_Area/Aout.dat")
fcount = open(areafile,'r')
line_count =0
for i in fcount:
if i != "\n":
line_count += 1
fcount.close()
f = open(areafile,'r')
j=0
for line in f:
data = line.split()
floats = []
for elem in data:
try:
floats.append(float(elem))
except ValueError:
pass
if j == 0:
columns = len(floats)
values = np.zeros([line_count,columns])
values[j,:] = np.array(floats)
j+= 1
f.close()
points = values[:,1:]
areavalues = np.array(values[:,0])
csvfile = (base_folder+os.sep+"Inputs/Model_Evaluation_Inputs/Model_Input_Data.csv")
inp = np.loadtxt(csvfile,delimiter=',',skiprows=1)
yawreq = np.reshape(inp[:,3],(len(inp),1))
pitchreq = np.reshape(inp[:,4],(len(inp),1))
rotreq = inp[:,12:]
request = np.hstack((yawreq,pitchreq,rotreq))
interp=NearestNDInterpolator(points, areavalues)
project_area = interp(request)
print(project_area)
