def main(netcdf_ws=os.getcwd(), ancillary_ws=os.getcwd(),
output_ws=os.getcwd(), start_date=None, end_date=None,
extent_path=None, output_extent=None,
stats_flag=True, overwrite_flag=False):
"""Extract DAYMET precipitation
Args:
netcdf_ws (str): folder of DAYMET netcdf files
ancillary_ws (str): folder of ancillary rasters
output_ws (str): folder of output rasters
start_date (str): ISO format date (YYYY-MM-DD)
end_date (str): ISO format date (YYYY-MM-DD)
extent_path (str): file path defining the output extent
output_extent (list): decimal degrees values defining output extent
stats_flag (bool): if True, compute raster statistics.
Default is True.
overwrite_flag (bool): if True, overwrite existing files
Returns:
None
"""
logging.info('\nExtracting DAYMET precipitation')
# If a date is not set, process 2015
try:
start_dt = dt.datetime.strptime(start_date, '%Y-%m-%d')
logging.debug(' Start date: {}'.format(start_dt))
except:
start_dt = dt.datetime(2015, 1, 1)
logging.info(' Start date: {}'.format(start_dt))
try:
end_dt = dt.datetime.strptime(end_date, '%Y-%m-%d')
logging.debug(' End date: {}'.format(end_dt))
except:
end_dt = dt.datetime(2015, 12, 31)
logging.info(' End date: {}'.format(end_dt))
# Save DAYMET lat, lon, and elevation arrays
mask_raster = os.path.join(ancillary_ws, 'daymet_mask.img')
daymet_re = re.compile('daymet_v3_(?P<VAR>\w+)_(?P<YEAR>\d{4})_na.nc4$')
# DAYMET band name dictionary
# daymet_band_dict = dict()
# daymet_band_dict['prcp'] = 'precipitation_amount'
# daymet_band_dict['srad'] = 'surface_downwelling_shortwave_flux_in_air'
# daymet_band_dict['sph'] = 'specific_humidity'
# daymet_band_dict['tmin'] = 'air_temperature'
# daymet_band_dict['tmax'] = 'air_temperature'
# Get extent/geo from mask raster
daymet_ds = gdal.Open(mask_raster)
daymet_osr = gdc.raster_ds_osr(daymet_ds)
daymet_proj = gdc.osr_proj(daymet_osr)
daymet_cs = gdc.raster_ds_cellsize(daymet_ds, x_only=True)
daymet_extent = gdc.raster_ds_extent(daymet_ds)
daymet_geo = daymet_extent.geo(daymet_cs)
daymet_x, daymet_y = daymet_extent.origin()
daymet_ds = None
logging.debug(' Projection: {}'.format(daymet_proj))
logging.debug(' Cellsize: {}'.format(daymet_cs))
logging.debug(' Geo: {}'.format(daymet_geo))
logging.debug(' Extent: {}'.format(daymet_extent))
logging.debug(' Origin: {} {}'.format(daymet_x, daymet_y))
# Subset data to a smaller extent
if output_extent is not None:
logging.info('\nComputing subset extent & geo')
logging.debug(' Extent: {}'.format(output_extent))
# Assume input extent is in decimal degrees
output_extent = gdc.project_extent(
gdc.Extent(output_extent), gdc.epsg_osr(4326), daymet_osr, 0.001)
output_extent = gdc.intersect_extents([daymet_extent, output_extent])
output_extent.adjust_to_snap('EXPAND', daymet_x, daymet_y, daymet_cs)
output_geo = output_extent.geo(daymet_cs)
logging.debug(' Geo: {}'.format(output_geo))
logging.debug(' Extent: {}'.format(output_extent))
elif extent_path is not None:
logging.info('\nComputing subset extent & geo')
if extent_path.lower().endswith('.shp'):
output_extent = gdc.feature_path_extent(extent_path)
extent_osr = gdc.feature_path_osr(extent_path)
extent_cs = None
else:
output_extent = gdc.raster_path_extent(extent_path)
extent_osr = gdc.raster_path_osr(extent_path)
extent_cs = gdc.raster_path_cellsize(extent_path, x_only=True)
output_extent = gdc.project_extent(
output_extent, extent_osr, daymet_osr, extent_cs)
output_extent = gdc.intersect_extents([daymet_extent, output_extent])
output_extent.adjust_to_snap('EXPAND', daymet_x, daymet_y, daymet_cs)
output_geo = output_extent.geo(daymet_cs)
logging.debug(' Geo: {}'.format(output_geo))
logging.debug(' Extent: {}'.format(output_extent))
else:
output_extent = daymet_extent.copy()
output_geo = daymet_geo[:]
# output_shape = output_extent.shape(cs=daymet_cs)
xi, yi = gdc.array_geo_offsets(daymet_geo, output_geo, daymet_cs)
output_rows, output_cols = output_extent.shape(daymet_cs)
logging.debug(' Shape: {} {}'.format(output_rows, output_cols))
logging.debug(' Offsets: {} {} (x y)'.format(xi, yi))
# Process each variable
input_var = 'prcp'
output_var = 'ppt'
logging.info("\nVariable: {}".format(input_var))
# Build output folder
var_ws = os.path.join(output_ws, output_var)
if not os.path.isdir(var_ws):
os.makedirs(var_ws)
# Process each file in the input workspace
for input_name in sorted(os.listdir(netcdf_ws)):
logging.debug("{}".format(input_name))
input_match = daymet_re.match(input_name)
if not input_match:
logging.debug(' Regular expression didn\'t match, skipping')
continue
elif input_match.group('VAR') != input_var:
logging.debug(' Variable didn\'t match, skipping')
continue
year_str = input_match.group('YEAR')
logging.info(" Year: {}".format(year_str))
year_int = int(year_str)
year_days = int(dt.datetime(year_int, 12, 31).strftime('%j'))
if start_dt is not None and year_int < start_dt.year:
logging.debug(' Before start date, skipping')
continue
elif end_dt is not None and year_int > end_dt.year:
logging.debug(' After end date, skipping')
continue
# Build input file path
input_raster = os.path.join(netcdf_ws, input_name)
# if not os.path.isfile(input_raster):
# logging.debug(
# ' Input raster doesn\'t exist, skipping {}'.format(
# input_raster))
# continue
# Build output folder
output_year_ws = os.path.join(var_ws, year_str)
if not os.path.isdir(output_year_ws):
os.makedirs(output_year_ws)
# Read in the DAYMET NetCDF file
input_nc_f = netCDF4.Dataset(input_raster, 'r')
# logging.debug(input_nc_f.variables)
# Check all valid dates in the year
year_dates = date_range(
dt.datetime(year_int, 1, 1), dt.datetime(year_int + 1, 1, 1))
for date_dt in year_dates:
if start_dt is not None and date_dt < start_dt:
logging.debug(' {} - before start date, skipping'.format(
date_dt.date()))
continue
elif end_dt is not None and date_dt > end_dt:
logging.debug(' {} - after end date, skipping'.format(
date_dt.date()))
continue
else:
logging.info(' {}'.format(date_dt.date()))
output_path = os.path.join(
output_year_ws, '{}_{}_daymet.img'.format(
output_var, date_dt.strftime('%Y%m%d')))
if os.path.isfile(output_path):
logging.debug(' {}'.format(output_path))
if not overwrite_flag:
logging.debug(' File already exists, skipping')
continue
else:
logging.debug(' File already exists, removing existing')
os.remove(output_path)
doy = int(date_dt.strftime('%j'))
doy_i = range(1, year_days + 1).index(doy)
# Arrays are being read as masked array with a fill value of -9999
# Convert to basic numpy array arrays with nan values
try:
input_ma = input_nc_f.variables[input_var][
doy_i, yi: yi + output_rows, xi: xi + output_cols]
except IndexError:
logging.info(' date not in netcdf, skipping')
continue
input_nodata = float(input_ma.fill_value)
output_array = input_ma.data.astype(np.float32)
output_array[output_array == input_nodata] = np.nan
# Save the array as 32-bit floats
gdc.array_to_raster(
output_array.astype(np.float32), output_path,
output_geo=output_geo, output_proj=daymet_proj,
stats_flag=stats_flag)
del input_ma, output_array
input_nc_f.close()
del input_nc_f
logging.debug('\nScript Complete')
def main(netcdf_ws=os.getcwd(),
ancillary_ws=os.getcwd(),
output_ws=os.getcwd(),
variables=['prcp'],
daily_flag=False,
monthly_flag=True,
annual_flag=False,
start_year=1981,
end_year=2010,
extent_path=None,
output_extent=None,
stats_flag=True,
overwrite_flag=False):
"""Extract DAYMET temperature
Args:
netcdf_ws (str): folder of DAYMET netcdf files
ancillary_ws (str): folder of ancillary rasters
output_ws (str): folder of output rasters
variables (list): DAYMET variables to download
('prcp', 'srad', 'vp', 'tmmn', 'tmmx')
Set as ['all'] to process all variables
daily_flag (bool): if True, compute daily (DOY) climatologies
monthly_flag (bool): if True, compute monthly climatologies
annual_flag (bool): if True, compute annual climatologies
start_year (int): YYYY
end_year (int): YYYY
extent_path (str): filepath a raster defining the output extent
output_extent (list): decimal degrees values defining output extent
stats_flag (bool): if True, compute raster statistics.
Default is True.
overwrite_flag (bool): if True, overwrite existing files
Returns:
None
"""
logging.info('\nGenerating DAYMET climatologies')
daily_fmt = 'daymet_{var}_30yr_normal_{doy:03d}.img'
monthly_fmt = 'daymet_{var}_30yr_normal_{month:02d}.img'
annual_fmt = 'daymet_{var}_30yr_normal.img'
# daily_fmt = 'daymet_{var}_normal_{start}_{end}_{doy:03d}.img'
# monthly_fmt = 'daymet_{var}_normal_{start}_{end}_{month:02d}.img'
# annual_fmt = 'daymet_{var}_normal_{start}_{end}.img'
# If a date is not set, process 1981-2010 climatology
try:
start_dt = dt.datetime(start_year, 1, 1)
logging.debug(' Start date: {}'.format(start_dt))
except:
start_dt = dt.datetime(1981, 1, 1)
logging.info(' Start date: {}'.format(start_dt))
try:
end_dt = dt.datetime(end_year, 12, 31)
logging.debug(' End date: {}'.format(end_dt))
except:
end_dt = dt.datetime(2010, 12, 31)
logging.info(' End date: {}'.format(end_dt))
# Get DAYMET spatial reference from an ancillary raster
mask_raster = os.path.join(ancillary_ws, 'daymet_mask.img')
daymet_re = re.compile('daymet_v3_(?P<VAR>\w+)_(?P<YEAR>\d{4})_na.nc4$')
# DAYMET rasters to extract
var_full_list = ['prcp', 'tmmn', 'tmmx']
# data_full_list = ['prcp', 'srad', 'vp', 'tmmn', 'tmmx']
if not variables:
logging.error('\nERROR: variables parameter is empty\n')
sys.exit()
elif type(variables) is not list:
# DEADBEEF - I could try converting comma separated strings to lists?
logging.warning('\nERROR: variables parameter must be a list\n')
sys.exit()
elif 'all' in variables:
logging.error('\nDownloading all variables\n {}'.format(
','.join(var_full_list)))
var_list = var_full_list[:]
elif not set(variables).issubset(set(var_full_list)):
logging.error(
'\nERROR: variables parameter is invalid\n {}'.format(variables))
sys.exit()
else:
var_list = variables[:]
# Get extent/geo from mask raster
daymet_ds = gdal.Open(mask_raster)
daymet_osr = gdc.raster_ds_osr(daymet_ds)
daymet_proj = gdc.osr_proj(daymet_osr)
daymet_cs = gdc.raster_ds_cellsize(daymet_ds, x_only=True)
daymet_extent = gdc.raster_ds_extent(daymet_ds)
daymet_geo = daymet_extent.geo(daymet_cs)
daymet_x, daymet_y = daymet_extent.origin()
daymet_ds = None
logging.debug(' Projection: {}'.format(daymet_proj))
logging.debug(' Cellsize: {}'.format(daymet_cs))
logging.debug(' Geo: {}'.format(daymet_geo))
logging.debug(' Extent: {}'.format(daymet_extent))
logging.debug(' Origin: {} {}'.format(daymet_x, daymet_y))
# Subset data to a smaller extent
if output_extent is not None:
logging.info('\nComputing subset extent & geo')
logging.debug(' Extent: {}'.format(output_extent))
# Assume input extent is in decimal degrees
output_extent = gdc.project_extent(gdc.Extent(output_extent),
gdc.epsg_osr(4326), daymet_osr,
0.001)
output_extent = gdc.intersect_extents([daymet_extent, output_extent])
output_extent.adjust_to_snap('EXPAND', daymet_x, daymet_y, daymet_cs)
output_geo = output_extent.geo(daymet_cs)
logging.debug(' Geo: {}'.format(output_geo))
logging.debug(' Extent: {}'.format(output_extent))
elif extent_path is not None:
logging.info('\nComputing subset extent & geo')
output_extent = gdc.project_extent(
gdc.raster_path_extent(extent_path),
gdc.raster_path_osr(extent_path), daymet_osr,
gdc.raster_path_cellsize(extent_path, x_only=True))
output_extent = gdc.intersect_extents([daymet_extent, output_extent])
output_extent.adjust_to_snap('EXPAND', daymet_x, daymet_y, daymet_cs)
output_geo = output_extent.geo(daymet_cs)
logging.debug(' Geo: {}'.format(output_geo))
logging.debug(' Extent: {}'.format(output_extent))
else:
output_extent = daymet_extent.copy()
output_geo = daymet_geo[:]
output_shape = output_extent.shape(cs=daymet_cs)
xi, yi = gdc.array_geo_offsets(daymet_geo, output_geo, daymet_cs)
output_rows, output_cols = output_extent.shape(daymet_cs)
logging.debug(' Shape: {} {}'.format(output_rows, output_cols))
logging.debug(' Offsets: {} {} (x y)'.format(xi, yi))
# Process each variable
for input_var in var_list:
logging.info("\nVariable: {}".format(input_var))
# Rename variables to match cimis
if input_var == 'prcp':
output_var = 'ppt'
else:
output_var = input_var
logging.debug("Output name: {}".format(output_var))
# Build output folder
var_ws = os.path.join(output_ws, output_var)
if not os.path.isdir(var_ws):
os.makedirs(var_ws)
# Build output arrays
logging.debug(' Building arrays')
if daily_flag:
daily_sum = np.full((365, output_shape[0], output_shape[1]), 0,
np.float64)
daily_count = np.full((365, output_shape[0], output_shape[1]), 0,
np.uint8)
if monthly_flag:
monthly_sum = np.full((12, output_shape[0], output_shape[1]), 0,
np.float64)
monthly_count = np.full((12, output_shape[0], output_shape[1]), 0,
np.uint8)
if monthly_flag:
annual_sum = np.full((output_shape[0], output_shape[1]), 0,
np.float64)
annual_count = np.full((output_shape[0], output_shape[1]), 0,
np.uint8)
# Process each file/year separately
for input_name in sorted(os.listdir(netcdf_ws)):
logging.debug(" {}".format(input_name))
input_match = daymet_re.match(input_name)
if not input_match:
logging.debug(' Regular expression didn\'t match, skipping')
continue
elif input_match.group('VAR') != input_var:
logging.debug(' Variable didn\'t match, skipping')
continue
year_str = input_match.group('YEAR')
logging.info(" Year: {}".format(year_str))
year_int = int(year_str)
year_days = int(dt.datetime(year_int, 12, 31).strftime('%j'))
if start_dt is not None and year_int < start_dt.year:
logging.debug(' Before start date, skipping')
continue
elif end_dt is not None and year_int > end_dt.year:
logging.debug(' After end date, skipping')
continue
# Build input file path
input_raster = os.path.join(netcdf_ws, input_name)
if not os.path.isfile(input_raster):
logging.debug(
' Input raster doesn\'t exist, skipping {}'.format(
input_raster))
continue
# Build output folder
if daily_flag:
daily_ws = os.path.join(var_ws, 'daily')
if not os.path.isdir(daily_ws):
os.makedirs(daily_ws)
if monthly_flag:
monthly_temp_sum = np.full(
(12, output_shape[0], output_shape[1]), 0, np.float64)
monthly_temp_count = np.full(
(12, output_shape[0], output_shape[1]), 0, np.uint8)
# Read in the DAYMET NetCDF file
input_nc_f = netCDF4.Dataset(input_raster, 'r')
# logging.debug(input_nc_f.variables)
# Check all valid dates in the year
year_dates = date_range(dt.datetime(year_int, 1, 1),
dt.datetime(year_int + 1, 1, 1))
for date_dt in year_dates:
logging.debug(' {}'.format(date_dt.date()))
# if start_dt is not None and date_dt < start_dt:
# logging.debug(
# ' {} - before start date, skipping'.format(
# date_dt.date()))
# continue
# elif end_dt is not None and date_dt > end_dt:
# logging.debug(' {} - after end date, skipping'.format(
# date_dt.date()))
# continue
# else:
# logging.info(' {}'.format(date_dt.date()))
doy = int(date_dt.strftime('%j'))
doy_i = range(1, year_days + 1).index(doy)
month_i = date_dt.month - 1
# Arrays are being read as masked array with a -9999 fill value
# Convert to basic numpy array arrays with nan values
try:
input_ma = input_nc_f.variables[input_var][doy_i, yi:yi +
output_rows,
xi:xi +
output_cols]
except IndexError:
logging.info(' date not in netcdf, skipping')
continue
input_nodata = float(input_ma.fill_value)
output_array = input_ma.data.astype(np.float32)
output_array[output_array == input_nodata] = np.nan
output_mask = np.isfinite(output_array)
# Convert Kelvin to Celsius
if input_var in ['tmax', 'tmin']:
output_array -= 273.15
# Save values
if daily_flag:
daily_sum[doy_i, :, :] += output_array
daily_count[doy_i, :, :] += output_mask
if monthly_flag:
monthly_temp_sum[month_i, :, :] += output_array
monthly_temp_count[month_i, :, :] += output_mask
if annual_flag:
annual_sum[:, :] += output_array
annual_count[:, :] += output_mask
# Cleanup
# del input_ds, input_array
del input_ma, output_array, output_mask
# Compute mean monthly for the year
if monthly_flag:
# Sum precipitation
if input_var == 'prcp':
monthly_sum += monthly_temp_sum
else:
monthly_sum += monthly_temp_sum / monthly_temp_count
# Is this the right count?
monthly_count += np.any(monthly_temp_count, axis=0)
del monthly_temp_sum, monthly_temp_count
input_nc_f.close()
del input_nc_f
# Save the projected climatology arrays
if daily_flag:
for doy_i in range(daily_sum.shape[0]):
daily_name = daily_fmt.format(var=output_var,
start=start_year,
end=end_year,
doy=doy_i + 1)
daily_path = os.path.join(daily_ws, daily_name)
gdc.array_to_raster(daily_sum[doy_i, :, :] /
daily_count[doy_i, :, :],
daily_path,
output_geo=output_geo,
output_proj=daymet_proj,
stats_flag=stats_flag)
del daily_sum, daily_count
if monthly_flag:
for month_i in range(monthly_sum.shape[0]):
monthly_name = monthly_fmt.format(var=output_var,
start=start_year,
end=end_year,
month=month_i + 1)
monthly_path = os.path.join(var_ws, monthly_name)
gdc.array_to_raster(monthly_sum[month_i, :, :] /
monthly_count[month_i, :, :],
monthly_path,
output_geo=output_geo,
output_proj=daymet_proj,
stats_flag=stats_flag)
del monthly_sum, monthly_count
if annual_flag:
annual_name = annual_fmt.format(var=output_var,
start=start_year,
end=end_year)
annual_path = os.path.join(var_ws, annual_name)
gdc.array_to_raster(annual_sum / annual_count,
annual_path,
output_geo=output_geo,
output_proj=daymet_proj,
stats_flag=stats_flag)
del annual_sum, annual_count
logging.debug('\nScript Complete')