def EASE25CellGrid():
ease25 = EASE2_grid(25000)
lons, lats = np.meshgrid(ease25.londim, ease25.latdim)
lats = np.flipud(lats) # flip lats, so that origin in bottom left
grid = BasicGrid(lons.flatten(),
lats.flatten(),
shape=(ease25.londim.size,
ease25.latdim.size)).to_cell_grid(5., 5.)
return grid
def reshuffle(input_root, outputpath, startdate, enddate,
parameters, overpass=None, crid=None, imgbuffer=50):
"""
Reshuffle method applied to ERA-Interim data.
Parameters
----------
input_root: string
input path where era interim data was downloaded
outputpath : string
Output path.
startdate : datetime
Start date.
enddate : datetime
End date.
parameters: list
parameters to read and convert
overpass : str
Select 'AM' for the descending overpass or 'PM' for the ascending one.
If the version data does not contain multiple overpasses, this must be None
crid : int, optional (default: None)
Search for files with this Composite Release ID for reshuffling only.
See also https://nsidc.org/data/smap/data_versions#CRID
imgbuffer: int, optional
How many images to read at once before writing time series.
"""
input_dataset = SPL3SMP_Ds(input_root, parameter=parameters,
overpass=overpass, crid=crid, flatten=True)
global_attr = {'product': 'SPL3SMP'}
if overpass:
global_attr['overpass'] = overpass
if not os.path.exists(outputpath):
os.makedirs(outputpath)
# get time series attributes from first day of data.
data = input_dataset.read(startdate)
ts_attributes = data.metadata
ease36 = EASE2_grid(36000)
lons, lats = np.meshgrid(ease36.londim, ease36.latdim)
grid = BasicGrid(lons.flatten(), lats.flatten())
reshuffler = Img2Ts(input_dataset=input_dataset, outputpath=outputpath,
startdate=startdate, enddate=enddate, input_grid=grid,
imgbuffer=imgbuffer, cellsize_lat=5.0, cellsize_lon=5.0,
global_attr=global_attr, ts_attributes=ts_attributes)
reshuffler.calc()
def test_EASE2_global_25km():
test_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'test_data')
test_lat = os.path.join(test_path, 'EASE2_M25km.lats.1388x584x1.double')
test_lon = os.path.join(test_path, 'EASE2_M25km.lons.1388x584x1.double')
egrid = EASE2_grid(25000, map_scale=25025.2600081)
assert egrid.shape == (584, 1388)
nptest.assert_almost_equal(egrid.map_scale, 25025.2600081)
lat_should = np.fromfile(test_lat, dtype=np.float64)
lon_should = np.fromfile(test_lon, dtype=np.float64)
nptest.assert_almost_equal(egrid.londim,
lon_should.reshape((584, 1388))[100, :])
nptest.assert_almost_equal(egrid.latdim,
lat_should.reshape((584, 1388))[:, 120])
def test_EASE2_global_36km():
test_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'test_data')
test_lat = os.path.join(test_path, 'EASE2_M36km.lats.964x406x1.double')
test_lon = os.path.join(test_path, 'EASE2_M36km.lons.964x406x1.double')
egrid = EASE2_grid(36000)
assert egrid.shape == (406, 964)
nptest.assert_almost_equal(egrid.x_pixel, egrid.map_scale)
nptest.assert_almost_equal(egrid.y_pixel, egrid.map_scale)
nptest.assert_almost_equal(egrid.map_scale, 36032.220840583752)
lat_should = np.fromfile(test_lat, dtype=np.float64)
lon_should = np.fromfile(test_lon, dtype=np.float64)
nptest.assert_almost_equal(egrid.londim,
lon_should.reshape((406, 964))[0, :])
nptest.assert_almost_equal(egrid.latdim,
lat_should.reshape((406, 964))[:, 0])
def reshuffle(input_root, outputpath,
startdate, enddate,
parameters,
imgbuffer=50):
"""
Reshuffle method applied to ERA-Interim data.
Parameters
----------
input_root: string
input path where era interim data was downloaded
outputpath : string
Output path.
startdate : datetime
Start date.
enddate : datetime
End date.
parameters: list
parameters to read and convert
imgbuffer: int, optional
How many images to read at once before writing time series.
"""
input_dataset = SPL3SMP_Ds(input_root, parameter=parameters, flatten=True)
if not os.path.exists(outputpath):
os.makedirs(outputpath)
global_attr = {'product': 'SPL3SMP'}
# get time series attributes from first day of data.
data = input_dataset.read(startdate)
ts_attributes = data.metadata
ease36 = EASE2_grid(36000)
lons, lats = np.meshgrid(ease36.londim, ease36.latdim)
grid = BasicGrid(lons.flatten(), lats.flatten())
reshuffler = Img2Ts(input_dataset=input_dataset, outputpath=outputpath,
startdate=startdate, enddate=enddate,
input_grid=grid,
imgbuffer=imgbuffer, cellsize_lat=5.0, cellsize_lon=5.0,
global_attr=global_attr,
ts_attributes=ts_attributes)
reshuffler.calc()
def __init__(self, bbox=None):
"""
Parameters
----------
bbox: tuple, optional (default: None)
(min_lon, min_lat, max_lon, max_lat)
Bounding box to create subset for, if None is passed a global
grid is used.
"""
ease25 = EASE2_grid(25000)
lons, lats = ease25.londim, ease25.latdim
lons, lats = np.meshgrid(lons, lats)
assert lons.shape == lats.shape
shape = lons.shape
lats = np.flipud(lats) # flip lats, so that origin in bottom left
lons, lats = lons.flatten(), lats.flatten()
globgrid = BasicGrid(lons, lats, shape=shape)
sgpis = globgrid.activegpis
self.bbox = bbox
if self.bbox:
sgpis = globgrid.get_bbox_grid_points(latmin=self.bbox[1],
latmax=self.bbox[3],
lonmin=self.bbox[0],
lonmax=self.bbox[2])
self.cellsize = 5.
super(EASE25CellGrid,
self).__init__(lon=globgrid.arrlon,
lat=globgrid.arrlat,
subset=sgpis,
cells=lonlat2cell(globgrid.arrlon,
globgrid.arrlat, self.cellsize),
shape=shape)
self.subset_shape = (len(np.unique(self.activearrlat)),
len(np.unique(self.activearrlon)))
# k += 1
#
# print "a"
#
from netCDF4 import Dataset
import os
path_ = "C:\Users\HPZ640\Downloads"
fr = Dataset(os.path.join(path_, 'air.mon.mean.nc'))
air = fr.variables['air'][0, :, :]
lat = fr.variables['lat'][:]
lon = fr.variables['lon'][:]
fr.close()
from ease_grid import EASE2_grid
egrid = EASE2_grid(25000)
assert egrid.shape == (586, 1383)
# these two attributes contain the longitude and latitude coordinate dimension
egrid.londim
egrid.latdim
import numpy
lats = numpy.fromfile('EASE2_M25km.lats.1388x584x1.double',
dtype=numpy.float64).reshape((584, 1386))
lons = numpy.fromfile('EASE2_M25km.lons.1388x584x1.double',
dtype=numpy.float64).reshape((584, 1386))
import pyresample
file_ = "data.h5"
from ease_grid import EASE2_grid
from itertools import chain
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap
egrid = EASE2_grid(36000)
assert egrid.shape == (406, 964)
# these two attributes contain the longitude and latitude coordinate dimension
print(egrid.londim)
print(egrid.latdim)
# print(egrid)
def draw_map(m, scale=0.2):
# draw a shaded-relief image
m.shadedrelief(scale=scale)
# lats and longs are returned as a dictionary
# lats = m.drawparallels(np.linspace(-90, 90, 13))
# lons = m.drawmeridians(np.linspace(-180, 180, 13))
lats = m.drawparallels(np.array(egrid.latdim))
lons = m.drawmeridians(np.array(egrid.londim))
# print(lats)
# keys contain the plt.Line2D instances
lat_lines = chain(*(tup[1][0] for tup in lats.items()))
lon_lines = chain(*(tup[1][0] for tup in lons.items()))
all_lines = chain(lat_lines, lon_lines)
# print(lat_lines)