def _get_2d_annual_climate(self, heights, year):
# Avoid code duplication with a getter routine
year = np.floor(year)
if self.repeat:
year = self.ys + (year - self.ys) % (self.ye - self.ys + 1)
if year < self.ys or year > self.ye:
raise ValueError('year {} out of the valid time bounds: '
'[{}, {}]'.format(year, self.ys, self.ye))
pok = np.where(self.years == year)[0]
if len(pok) < 1:
raise ValueError('Year {} not in record'.format(int(year)))
# Read timeseries
itemp = self.temp[pok] + self.temp_bias
iprcp = self.prcp[pok] * self.prcp_bias
igrad = self.grad[pok]
# For each height pixel:
# Compute temp and tempformelt (temperature above melting threshold)
heights = np.asarray(heights)
npix = len(heights)
grad_temp = np.atleast_2d(igrad).repeat(npix, 0)
grad_temp *= (heights.repeat(12).reshape(grad_temp.shape) -
self.ref_hgt)
temp2d = np.atleast_2d(itemp).repeat(npix, 0) + grad_temp
temp2dformelt = temp2d - self.t_melt
clip_min(temp2dformelt, 0, out=temp2dformelt)
# Compute solid precipitation from total precipitation
prcp = np.atleast_2d(iprcp).repeat(npix, 0)
fac = 1 - (temp2d - self.t_solid) / (self.t_liq - self.t_solid)
prcpsol = prcp * clip_array(fac, 0, 1)
return temp2d, temp2dformelt, prcp, prcpsol
def get_monthly_climate(self, heights, year=None):
"""Monthly climate information at given heights.
Note that prcp is corrected with the precipitation factor and that
all other model biases (temp and prcp) are applied.
Returns
-------
(temp, tempformelt, prcp, prcpsol)
"""
y, m = floatyear_to_date(year)
if self.repeat:
y = self.ys + (y - self.ys) % (self.ye - self.ys + 1)
if y < self.ys or y > self.ye:
raise ValueError('year {} out of the valid time bounds: '
'[{}, {}]'.format(y, self.ys, self.ye))
pok = np.where((self.years == y) & (self.months == m))[0][0]
# Read timeseries
itemp = self.temp[pok] + self.temp_bias
iprcp = self.prcp[pok] * self.prcp_bias
igrad = self.grad[pok]
# For each height pixel:
# Compute temp and tempformelt (temperature above melting threshold)
npix = len(heights)
temp = np.ones(npix) * itemp + igrad * (heights - self.ref_hgt)
tempformelt = temp - self.t_melt
clip_min(tempformelt, 0, out=tempformelt)
# Compute solid precipitation from total precipitation
prcp = np.ones(npix) * iprcp
fac = 1 - (temp - self.t_solid) / (self.t_liq - self.t_solid)
prcpsol = prcp * clip_array(fac, 0, 1)
return temp, tempformelt, prcp, prcpsol
def mass_conservation_inversion(gdir,
glen_a=None,
fs=None,
write=True,
filesuffix=''):
""" Compute the glacier thickness along the flowlines
More or less following Farinotti et al., (2009).
Parameters
----------
gdir : :py:class:`oggm.GlacierDirectory`
the glacier directory to process
glen_a : float
glen's creep parameter A
fs : float
sliding parameter
write: bool
default behavior is to compute the thickness and write the
results in the pickle. Set to False in order to spare time
during calibration.
filesuffix : str
add a suffix to the output file
"""
# Defaults
if glen_a is None:
glen_a = cfg.PARAMS['inversion_glen_a']
if fs is None:
fs = cfg.PARAMS['inversion_fs']
# Check input
_inv_function = _inversion_simple if fs == 0 else _inversion_poly
# Ice flow params
fd = 2. / (cfg.PARAMS['glen_n'] + 2) * glen_a
a3 = fs / fd
rho = cfg.PARAMS['ice_density']
# Inversion with shape factors?
sf_func = None
use_sf = cfg.PARAMS.get('use_shape_factor_for_inversion', None)
if use_sf == 'Adhikari' or use_sf == 'Nye':
sf_func = utils.shape_factor_adhikari
elif use_sf == 'Huss':
sf_func = utils.shape_factor_huss
# Clip the slope, in degrees
clip_angle = cfg.PARAMS['min_slope']
out_volume = 0.
cls = gdir.read_pickle('inversion_input')
for cl in cls:
# Clip slope to avoid negative and small slopes
slope = cl['slope_angle']
slope = utils.clip_array(slope, np.deg2rad(clip_angle), np.pi / 2.)
# Glacier width
w = cl['width']
a0s = -cl['flux_a0'] / ((rho * cfg.G * slope)**3 * fd)
sf = np.ones(slope.shape) # Default shape factor is 1
if sf_func is not None:
# Start iteration for shape factor with first guess of 1
i = 0
sf_diff = np.ones(slope.shape)
# Some hard-coded factors here
sf_tol = 1e-2
max_sf_iter = 20
while i < max_sf_iter and np.any(sf_diff > sf_tol):
out_thick = _compute_thick(a0s, a3, cl['flux_a0'], sf,
_inv_function)
sf_diff[:] = sf[:]
sf = sf_func(w, out_thick, cl['is_rectangular'])
sf_diff = sf_diff - sf
i += 1
log.info('Shape factor {:s} used, took {:d} iterations for '
'convergence.'.format(use_sf, i))
# TODO: possible shape factor optimisations
# thick update could be used as iteration end criterion instead
# we iterate for all grid points, even if some already converged
out_thick = _compute_thick(a0s, a3, cl['flux_a0'], sf, _inv_function)
# volume
fac = np.where(cl['is_rectangular'], 1, 2. / 3.)
volume = fac * out_thick * w * cl['dx']
if write:
cl['thick'] = out_thick
cl['volume'] = volume
out_volume += np.sum(volume)
if write:
gdir.write_pickle(cls, 'inversion_output', filesuffix=filesuffix)
return out_volume, gdir.rgi_area_km2 * 1e6
def sia_thickness(slope,
width,
flux,
shape='rectangular',
glen_a=None,
fs=None,
shape_factor=None):
"""Computes the ice thickness from mass-conservation.
This is a utility function tested against the true OGGM inversion
function. Useful for teaching and inversion with calving.
Parameters
----------
slope : -np.gradient(hgt, dx)
width : section width in m
flux : mass flux in m3 s-1
shape : 'rectangular' or 'parabolic'
glen_a : Glen A, defaults to PARAMS
fs : sliding, defaults to PARAMS
shape_factor: for lateral drag
Returns
-------
the ice thickness (in m)
"""
if glen_a is None:
glen_a = cfg.PARAMS['inversion_glen_a']
if fs is None:
fs = cfg.PARAMS['inversion_fs']
if shape not in ['parabolic', 'rectangular']:
raise InvalidParamsError('shape must be `parabolic` or `rectangular`,'
'not: {}'.format(shape))
_inv_function = _inversion_simple if fs == 0 else _inversion_poly
# Ice flow params
fd = 2. / (cfg.PARAMS['glen_n'] + 2) * glen_a
rho = cfg.PARAMS['ice_density']
# Clip the slope, in degrees
clip_angle = cfg.PARAMS['min_slope']
# Clip slope to avoid negative and small slopes
slope = utils.clip_array(slope, np.deg2rad(clip_angle), np.pi / 2.)
# Convert the flux to m2 s-1 (averaged to represent the sections center)
flux_a0 = 1 if shape == 'rectangular' else 1.5
flux_a0 *= flux / width
# Polynomial factors (a5 = 1)
a0 = -flux_a0 / ((rho * cfg.G * slope)**3 * fd)
a3 = fs / fd
# Inversion with shape factors?
sf_func = None
if shape_factor == 'Adhikari' or shape_factor == 'Nye':
sf_func = utils.shape_factor_adhikari
elif shape_factor == 'Huss':
sf_func = utils.shape_factor_huss
sf = np.ones(slope.shape) # Default shape factor is 1
if sf_func is not None:
# Start iteration for shape factor with first guess of 1
i = 0
sf_diff = np.ones(slope.shape)
# Some hard-coded factors here
sf_tol = 1e-2
max_sf_iter = 20
while i < max_sf_iter and np.any(sf_diff > sf_tol):
out_thick = _compute_thick(a0, a3, flux_a0, sf, _inv_function)
is_rectangular = np.repeat(shape == 'rectangular', len(width))
sf_diff[:] = sf[:]
sf = sf_func(width, out_thick, is_rectangular)
sf_diff = sf_diff - sf
i += 1
log.info('Shape factor {:s} used, took {:d} iterations for '
'convergence.'.format(shape_factor, i))
return _compute_thick(a0, a3, flux_a0, sf, _inv_function)
def __init__(self,
gdir,
mu_star=None,
bias=None,
filename='climate_historical',
input_filesuffix='',
repeat=False,
ys=None,
ye=None,
check_calib_params=True):
"""Initialize.
Parameters
----------
gdir : GlacierDirectory
the glacier directory
mu_star : float, optional
set to the alternative value of mu* you want to use
(the default is to use the calibrated value).
bias : float, optional
set to the alternative value of the calibration bias [mm we yr-1]
you want to use (the default is to use the calibrated value)
Note that this bias is *substracted* from the computed MB. Indeed:
BIAS = MODEL_MB - REFERENCE_MB.
filename : str, optional
set to a different BASENAME if you want to use alternative climate
data.
input_filesuffix : str
the file suffix of the input climate file
repeat : bool
Whether the climate period given by [ys, ye] should be repeated
indefinitely in a circular way
ys : int
The start of the climate period where the MB model is valid
(default: the period with available data)
ye : int
The end of the climate period where the MB model is valid
(default: the period with available data)
check_calib_params : bool
OGGM will try hard not to use wrongly calibrated mu* by checking
the parameters used during calibration and the ones you are
using at run time. If they don't match, it will raise an error.
Set to False to suppress this check.
Attributes
----------
temp_bias : float, default 0
Add a temperature bias to the time series
prcp_bias : float, default 1
Precipitation factor to the time series (called bias for
consistency with `temp_bias`)
"""
super(PastMassBalance, self).__init__()
self.valid_bounds = [-1e4, 2e4] # in m
if mu_star is None:
df = gdir.read_json('local_mustar')
mu_star = df['mu_star_glacierwide']
if check_calib_params:
if not df['mu_star_allsame']:
msg = ('You seem to use the glacier-wide mu* to compute '
'the mass-balance although this glacier has '
'different mu* for its flowlines. Set '
'`check_calib_params=False` to prevent this '
'error.')
raise InvalidWorkflowError(msg)
if bias is None:
if cfg.PARAMS['use_bias_for_run']:
df = gdir.read_json('local_mustar')
bias = df['bias']
else:
bias = 0.
self.mu_star = mu_star
self.bias = bias
# Parameters
self.t_solid = cfg.PARAMS['temp_all_solid']
self.t_liq = cfg.PARAMS['temp_all_liq']
self.t_melt = cfg.PARAMS['temp_melt']
prcp_fac = cfg.PARAMS['prcp_scaling_factor']
default_grad = cfg.PARAMS['temp_default_gradient']
# Check the climate related params to the GlacierDir to make sure
if check_calib_params:
mb_calib = gdir.get_climate_info()['mb_calib_params']
for k, v in mb_calib.items():
if v != cfg.PARAMS[k]:
msg = ('You seem to use different mass-balance parameters '
'than used for the calibration. Set '
'`check_calib_params=False` to ignore this '
'warning.')
raise InvalidWorkflowError(msg)
# Public attrs
self.hemisphere = gdir.hemisphere
self.temp_bias = 0.
self.prcp_bias = 1.
self.repeat = repeat
# Read file
fpath = gdir.get_filepath(filename, filesuffix=input_filesuffix)
with ncDataset(fpath, mode='r') as nc:
# time
time = nc.variables['time']
time = netCDF4.num2date(time[:], time.units)
ny, r = divmod(len(time), 12)
if r != 0:
raise ValueError('Climate data should be N full years')
# This is where we switch to hydro float year format
# Last year gives the tone of the hydro year
self.years = np.repeat(
np.arange(time[-1].year - ny + 1, time[-1].year + 1), 12)
self.months = np.tile(np.arange(1, 13), ny)
# Read timeseries
self.temp = nc.variables['temp'][:]
self.prcp = nc.variables['prcp'][:] * prcp_fac
if 'gradient' in nc.variables:
grad = nc.variables['gradient'][:]
# Security for stuff that can happen with local gradients
g_minmax = cfg.PARAMS['temp_local_gradient_bounds']
grad = np.where(~np.isfinite(grad), default_grad, grad)
grad = clip_array(grad, g_minmax[0], g_minmax[1])
else:
grad = self.prcp * 0 + default_grad
self.grad = grad
self.ref_hgt = nc.ref_hgt
self.ys = self.years[0] if ys is None else ys
self.ye = self.years[-1] if ye is None else ye
def mass_conservation_inversion(gdir,
glen_a=None,
fs=None,
write=True,
filesuffix='',
water_level=None,
t_lambda=None):
""" Compute the glacier thickness along the flowlines
More or less following Farinotti et al., (2009).
Parameters
----------
gdir : :py:class:`oggm.GlacierDirectory`
the glacier directory to process
glen_a : float
glen's creep parameter A. Defaults to cfg.PARAMS.
fs : float
sliding parameter. Defaults to cfg.PARAMS.
write: bool
default behavior is to compute the thickness and write the
results in the pickle. Set to False in order to spare time
during calibration.
filesuffix : str
add a suffix to the output file
water_level : float
to compute volume below water level - adds an entry to the output dict
t_lambda : float
defining the angle of the trapezoid walls (see documentation). Defaults
to cfg.PARAMS.
"""
# Defaults
if glen_a is None:
glen_a = cfg.PARAMS['inversion_glen_a']
if fs is None:
fs = cfg.PARAMS['inversion_fs']
if t_lambda is None:
t_lambda = cfg.PARAMS['trapezoid_lambdas']
# Check input
_inv_function = _inversion_simple if fs == 0 else _inversion_poly
# Ice flow params
fd = 2. / (cfg.PARAMS['glen_n'] + 2) * glen_a
a3 = fs / fd
rho = cfg.PARAMS['ice_density']
# Inversion with shape factors?
sf_func = None
use_sf = cfg.PARAMS.get('use_shape_factor_for_inversion', None)
if use_sf == 'Adhikari' or use_sf == 'Nye':
sf_func = utils.shape_factor_adhikari
elif use_sf == 'Huss':
sf_func = utils.shape_factor_huss
# Clip the slope, in degrees
clip_angle = cfg.PARAMS['min_slope']
out_volume = 0.
cls = gdir.read_pickle('inversion_input')
for cl in cls:
# Clip slope to avoid negative and small slopes
slope = cl['slope_angle']
slope = utils.clip_array(slope, np.deg2rad(clip_angle), np.pi / 2.)
# Glacier width
w = cl['width']
a0s = -cl['flux_a0'] / ((rho * cfg.G * slope)**3 * fd)
sf = np.ones(slope.shape) # Default shape factor is 1
if sf_func is not None:
# Start iteration for shape factor with first guess of 1
i = 0
sf_diff = np.ones(slope.shape)
# Some hard-coded factors here
sf_tol = 1e-2
max_sf_iter = 20
while i < max_sf_iter and np.any(sf_diff > sf_tol):
out_thick = _compute_thick(a0s, a3, cl['flux_a0'], sf,
_inv_function)
sf_diff[:] = sf[:]
sf = sf_func(w, out_thick, cl['is_rectangular'])
sf_diff = sf_diff - sf
i += 1
log.info('Shape factor {:s} used, took {:d} iterations for '
'convergence.'.format(use_sf, i))
# TODO: possible shape factor optimisations
# thick update could be used as iteration end criterion instead
# we iterate for all grid points, even if some already converged
out_thick = _compute_thick(a0s, a3, cl['flux_a0'], sf, _inv_function)
# volume
is_rect = cl['is_rectangular']
fac = np.where(is_rect, 1, 2. / 3.)
volume = fac * out_thick * w * cl['dx']
# Now recompute thickness where parabola is too flat
is_trap = cl['is_trapezoid']
if cl['invert_with_trapezoid']:
min_shape = cfg.PARAMS['mixed_min_shape']
bed_shape = 4 * out_thick / w**2
is_trap = ((bed_shape < min_shape) & ~cl['is_rectangular'] &
(cl['flux'] > 0)) | is_trap
for i in np.where(is_trap)[0]:
try:
out_thick[i] = sia_thickness_via_optim(slope[i],
w[i],
cl['flux'][i],
shape='trapezoid',
t_lambda=t_lambda,
glen_a=glen_a,
fs=fs)
sect = (2 * w[i] -
t_lambda * out_thick[i]) / 2 * out_thick[i]
volume[i] = sect * cl['dx']
except ValueError:
# no solution error - we do with rect
out_thick[i] = sia_thickness_via_optim(slope[i],
w[i],
cl['flux'][i],
shape='rectangular',
glen_a=glen_a,
fs=fs)
is_rect[i] = True
is_trap[i] = False
volume[i] = out_thick[i] * w[i] * cl['dx']
# Sanity check
if np.any(out_thick <= 0):
raise RuntimeError("Found zero or negative thickness: "
"this should not happen.")
if write:
cl['is_trapezoid'] = is_trap
cl['is_rectangular'] = is_rect
cl['thick'] = out_thick
cl['volume'] = volume
# volume below sl
try:
bed_h = cl['hgt'] - out_thick
bed_shape = 4 * out_thick / w**2
if np.any(bed_h < 0):
cl['volume_bsl'] = _vol_below_water(
cl['hgt'], bed_h, bed_shape, out_thick, w,
cl['is_rectangular'], cl['is_trapezoid'], fac,
t_lambda, cl['dx'], 0)
if water_level is not None and np.any(bed_h < water_level):
cl['volume_bwl'] = _vol_below_water(
cl['hgt'], bed_h, bed_shape, out_thick, w,
cl['is_rectangular'], cl['is_trapezoid'], fac,
t_lambda, cl['dx'], water_level)
except KeyError:
# cl['hgt'] is not available on old prepro dirs
pass
out_volume += np.sum(volume)
if write:
gdir.write_pickle(cls, 'inversion_output', filesuffix=filesuffix)
gdir.add_to_diagnostics('inversion_glen_a', glen_a)
gdir.add_to_diagnostics('inversion_fs', fs)
return out_volume
def _get_climate(self, heights, climate_type, year=None):
"""Climate information at given heights.
year has to be given as float hydro year from what the month is taken,
hence year 2000 -> y=2000, m = 1, & year = 2000.09, y=2000, m=2 ...
which corresponds to the real year 1999 an months October or November
if hydro year starts in October
Note that prcp is corrected with the precipitation factor and that
all other model biases (temp and prcp) are applied.
same as in OGGM default except that tempformelt is computed by
self._get_tempformelt
Parameters
-------
heights : np.array or list
heights along flowline
climate_type : str
either 'monthly' or 'annual', if annual floor of year is used,
if monthly float year is converted into month and year
Returns
-------
(temp, tempformelt, prcp, prcpsol)
"""
y, m = floatyear_to_date(year)
if self.repeat:
y = self.ys + (y - self.ys) % (self.ye - self.ys + 1)
if y < self.ys or y > self.ye:
raise ValueError('year {} out of the valid time bounds: '
'[{}, {}]'.format(y, self.ys, self.ye))
if self.mb_type == 'mb_real_daily' or climate_type == 'annual':
if climate_type == 'annual':
pok = np.where(self.years == year)[0]
if len(pok) < 1:
raise ValueError('Year {} not in record'.format(int(year)))
else:
pok = np.where((self.years == y) & (self.months == m))[0]
if len(pok) < 28:
warnings.warn('something goes wrong with amount of entries\
per month for mb_real_daily')
else:
pok = np.where((self.years == y) & (self.months == m))[0][0]
# Read timeseries
itemp = self.temp[pok] + self.temp_bias
iprcp = self.prcp[pok] * self.prcp_bias
igrad = self.grad[pok]
# For each height pixel:
# Compute temp and tempformelt (temperature above melting threshold)
heights = np.asarray(heights)
npix = len(heights)
if self.mb_type == 'mb_real_daily' or climate_type == 'annual':
grad_temp = np.atleast_2d(igrad).repeat(npix, 0)
if len(pok) != 12 and self.mb_type != 'mb_real_daily':
warnings.warn('something goes wrong with amount of entries'
'per year')
grad_temp *= (heights.repeat(len(pok)).reshape(grad_temp.shape) -
self.ref_hgt)
temp2d = np.atleast_2d(itemp).repeat(npix, 0) + grad_temp
# temp_for_melt is computed separately depending on mb_type
temp2dformelt = self._get_tempformelt(temp2d, pok)
# Compute solid precipitation from total precipitation
prcp = np.atleast_2d(iprcp).repeat(npix, 0)
fac = 1 - (temp2d - self.t_solid) / (self.t_liq - self.t_solid)
prcpsol = prcp * clip_array(fac, 0, 1)
return temp2d, temp2dformelt, prcp, prcpsol
else:
temp = np.ones(npix) * itemp + igrad * (heights - self.ref_hgt)
# temp_for_melt is computed separately depending on mb_type
tempformelt = self._get_tempformelt(temp, pok)
prcp = np.ones(npix) * iprcp
fac = 1 - (temp - self.t_solid) / (self.t_liq - self.t_solid)
prcpsol = prcp * clip_array(fac, 0, 1)
return temp, tempformelt, prcp, prcpsol
def __init__(self,
gdir,
mu_star,
bias=0,
mb_type='mb_daily',
N=10000,
loop=False,
grad_type='cte',
filename='climate_historical',
input_filesuffix='',
repeat=False,
ys=None,
ye=None,
t_solid=0,
t_liq=2,
t_melt=0,
prcp_fac=2.5,
default_grad=-0.0065,
temp_local_gradient_bounds=[-0.009, -0.003],
SEC_IN_YEAR=SEC_IN_YEAR,
SEC_IN_MONTH=SEC_IN_MONTH):
""" Initialize.
Parameters
----------
gdir : GlacierDirectory
the glacier directory
mu_star : float
monthly temperature sensitivity (kg /m² /mth /K),
need to be prescribed, e.g. such that
|mean(MODEL_MB)-mean(REF_MB)|--> 0
bias : float, optional
default is to use zero bias [mm we yr-1]
you want to use (the default is to use zero bias)
Note that this bias is *substracted* from the computed MB. Indeed:
BIAS = MODEL_MB - REFERENCE_MB.
mb_type: str
three types: 'mb_daily' (default: use temp_std and N percentiles),
'mb_monthly' (same as default OGGM mass balance),
'mb_real_daily' (use daily temperature values).
the mb_type only work if the baseline_climate of gdir is right
N : int
number of percentiles used to generate gaussian-like daily
temperatures from daily std and mean monthly temp
loop : bool
the way how the matrix multiplication is done,
using np.matmul or a loop(default: False)
only applied if mb_type is 'mb_daily'
which one is faster?
grad_type : str
three types of applying the temperature gradient:
'cte' (default, constant lapse rate, set to default_grad,
same as in default OGGM)
'var_an_cycle' (varies spatially and over annual cycle,
but constant over the years)
'var' (varies spatially & temporally as in the climate files)
filename : str, optional
set to a different BASENAME if you want to use alternative climate
data, default is climate_historical
input_filesuffix : str,
the file suffix of the input climate file, default is '',
if ERA5_daily with daily temperatures, it is set to _daily
repeat : bool
Whether the climate period given by [ys, ye] should be repeated
indefinitely in a circular way
ys : int
The start of the climate period where the MB model is valid
(default: the period with available data)
ye : int
The end of the climate period where the MB model is valid
(default: the period with available data)
t_solid : float
temperature threshold for solid precipitation
(degree Celsius, default 0)
t_liq: float
temperature threshold for liquid precipitation
(degree Celsius, default 2)
t_melt : float
temperature threshold where snow/ice melts
(degree Celsius, default 0)
prcp_fac : float, >0
multiplicative precipitation correction factor (default 2.5)
default_grad : float,
constant lapse rate (temperature gradient, default: -0.0065 m/K)
if grad_type != cte, then this value is not used
but instead the changing lapse rate from the climate datasets
temp_local_gradient_bounds : [float, float],
if grad_type != cte and the lapse rate does not lie in this range,
set it instead to these minimum, maximum gradients
(default: [-0.009, -0.003] m/K)
SEC_IN_YEAR: float
seconds in a year (default: 31536000s),
maybe this could be changed
SEC_IN_MONTH: float
seconds in a month (default: 2628000s),
maybe this could be changed as not each
month has the same amount of seconds,
in February can be a difference of 8%
Attributes
----------
temp_bias : float, default 0
Add a temperature bias to the time series
prcp_bias : float, default 1
Precipitation factor to the time series (called bias for
consistency with `temp_bias`)
"""
self.mu_star = mu_star
self.bias = bias
# Parameters (from cfg.PARAMS in OGGM default)
self.t_solid = t_solid
self.t_liq = t_liq
self.t_melt = t_melt
self.N = N
self.mb_type = mb_type
self.loop = loop
self.grad_type = grad_type
# default rho is 900 kg/m3
self.rho = cfg.PARAMS['ice_density']
# Public attrs
self.hemisphere = gdir.hemisphere
self.temp_bias = 0.
self.prcp_bias = 1.
self.repeat = repeat
self.SEC_IN_YEAR = SEC_IN_YEAR
self.SEC_IN_MONTH = SEC_IN_MONTH
# check if the right climate is used for the right mb_type
# these checks might be changed if there are more climate datasets
# available!!!
# only have daily temperatures for 'ERA5_daily'
baseline_climate = gdir.get_climate_info()['baseline_climate_source']
if (self.mb_type == 'mb_real_daily'
and baseline_climate != 'ERA5_daily'):
text = ('wrong climate for mb_real_daily, need to do e.g. '
'process_era5_daily_data(gd) to enable ERA5_daily')
raise InvalidParamsError(text)
# mb_monthly does not work when daily temperatures are used
if self.mb_type == 'mb_monthly' and baseline_climate == 'ERA5_daily':
text = ('wrong climate for mb_monthly, need to do e.g.'
'oggm.shop.ecmwf.process_ecmwf_data(gd, dataset="ERA5dr")')
raise InvalidParamsError(text)
# mb_daily needs temp_std
if self.mb_type == 'mb_daily' and baseline_climate == 'ERA5_daily':
text = 'wrong climate for mb_daily, need to do e.g. \
oggm.shop.ecmwf.process_ecmwf_data(gd, dataset = "ERA5dr")'
raise InvalidParamsError(text)
if baseline_climate == 'ERA5_daily':
input_filesuffix = '_daily'
# Read climate file
fpath = gdir.get_filepath(filename, filesuffix=input_filesuffix)
# used xarray instead of netCDF4, is this slower?
with xr.open_dataset(fpath) as xr_nc:
if self.mb_type == 'mb_real_daily' or self.mb_type == 'mb_monthly':
# even if there is temp_std inside the dataset, we won't use
# it for these mb_types
self.temp_std = np.NaN
else:
try:
self.temp_std = xr_nc['temp_std'].values
except KeyError:
text = ('The applied climate has no temp std, do e.g.'
'oggm.shop.ecmwf.process_ecmwf_data'
'(gd, dataset="ERA5dr")')
raise InvalidParamsError(text)
# goal is to get self.years/self.months in hydro_years
if self.mb_type != 'mb_real_daily':
time = xr_nc.time
ny, r = divmod(len(time), 12)
if r != 0:
raise ValueError('Climate data should be N full years')
# This is where we switch to hydro float year format
# Last year gives the tone of the hydro year
self.years = np.repeat(
np.arange(xr_nc.time[-1].dt.year - ny + 1,
xr_nc.time[-1].dt.year + 1), 12)
self.months = np.tile(np.arange(1, 13), ny)
elif self.mb_type == 'mb_real_daily':
# use pandas to convert month/year to hydro_years
# this has to be done differently than above because not
# every month, year has the same amount of days
pd_test = pd.DataFrame(xr_nc.time.to_series().dt.year.values,
columns=['year'])
pd_test.index = xr_nc.time.to_series().values
pd_test['month'] = xr_nc.time.to_series().dt.month.values
pd_test['hydro_year'] = np.NaN
# get the month where the hydrological month starts
# as chosen from the gdir climate file
# default 10 for 'nh', 4 for 'sh'
hydro_month_start = int(xr_nc.time[0].dt.month.values)
if hydro_month_start == 1:
# hydro_year corresponds to normal year
pd_test.loc[pd_test.index.month >= hydro_month_start,
'hydro_year'] = pd_test['year']
else:
pd_test.loc[pd_test.index.month < hydro_month_start,
'hydro_year'] = pd_test['year']
# otherwise, those days with a month>=hydro_month_start
# belong to the next hydro_year
pd_test.loc[pd_test.index.month >= hydro_month_start,
'hydro_year'] = pd_test['year'] + 1
# month_hydro is 1 if it is hydro_month_start
month_hydro = pd_test['month'].values + (12 -
hydro_month_start + 1)
month_hydro[month_hydro > 12] += -12
pd_test['hydro_month'] = month_hydro
pd_test = pd_test.astype('int')
self.years = pd_test['hydro_year'].values
ny = self.years[-1] - self.years[0] + 1
self.months = pd_test['hydro_month'].values
# Read timeseries
self.temp = xr_nc['temp'].values
self.prcp = xr_nc['prcp'].values * prcp_fac
# lapse rate (temperature gradient)
if self.grad_type == 'var' or self.grad_type == 'var_an_cycle':
try:
grad = xr_nc['gradient'].values
# Security for stuff that can happen with local gradients
g_minmax = temp_local_gradient_bounds
# if gradient is not a number, or positive/negative
# infinity, use the default gradient
grad = np.where(~np.isfinite(grad), default_grad, grad)
# if outside boundaries of default -0.009 and above
# -0.003 -> use the boundaries instead
grad = clip_array(grad, g_minmax[0], g_minmax[1])
if self.grad_type == 'var_an_cycle':
# if we want constant lapse rates over the years
# that change over the annual cycle, but not over time
if self.mb_type == 'mb_real_daily':
grad_gb = xr_nc['gradient'].groupby('time.month')
grad = grad_gb.mean().values
g_minmax = temp_local_gradient_bounds
# if gradient is not a number, or positive/negative
# infinity, use the default gradient
grad = np.where(~np.isfinite(grad), default_grad,
grad)
# if outside boundaries of default -0.009 and above
# -0.003 -> use the boundaries instead
grad = clip_array(grad, g_minmax[0], g_minmax[1])
stack_grad = grad.reshape(-1, 12)
grad = np.tile(stack_grad.mean(axis=0), ny)
reps_day1 = xr_nc.time[xr_nc.time.dt.day == 1]
reps = reps_day1.dt.daysinmonth
grad = np.repeat(grad, reps)
else:
stack_grad = grad.reshape(-1, 12)
grad = np.tile(stack_grad.mean(axis=0), ny)
except KeyError:
text = ('there is no gradient available in chosen climate'
'file, try instead e.g. ERA5_daily or ERA5dr e.g.'
'oggm.shop.ecmwf.process_ecmwf_data'
'(gd, dataset="ERA5dr")')
raise InvalidParamsError(text)
elif self.grad_type == 'cte':
# if grad_type is chosen cte, we use the default_grad!
grad = self.prcp * 0 + default_grad
else:
raise InvalidParamsError('grad_type can be either cte,'
'var or var_an_cycle')
self.grad = grad
self.ref_hgt = xr_nc.ref_hgt
self.ys = self.years[0] if ys is None else ys
self.ye = self.years[-1] if ye is None else ye
def mb_climate_on_height(gdir, heights, *, time_range=None, year_range=None):
"""Mass-balance climate of the glacier at a specific height
Reads the glacier's monthly climate data file and computes the
temperature "energies" (temp above 0) and solid precipitation at the
required height.
All MB parameters are considered here! (i.e. melt temp, precip scaling
factor, etc.)
Parameters
----------
gdir : GlacierDirectory
the glacier directory
heights: ndarray
a 1D array of the heights (in meter) where you want the data
time_range : [datetime, datetime], optional
default is to read all data but with this you
can provide a [t0, t1] bounds (inclusive).
year_range : [int, int], optional
Provide a [y0, y1] year range to get the data for specific
(hydrological) years only. Easier to use than the time bounds above.
Returns
-------
(time, tempformelt, prcpsol)::
- time: array of shape (nt,)
- tempformelt: array of shape (len(heights), nt)
- prcpsol: array of shape (len(heights), nt)
"""
if year_range is not None:
sm = cfg.PARAMS['hydro_month_' + gdir.hemisphere]
em = sm - 1 if (sm > 1) else 12
t0 = datetime.datetime(year_range[0] - 1, sm, 1)
t1 = datetime.datetime(year_range[1], em, 1)
return mb_climate_on_height(gdir, heights, time_range=[t0, t1])
# Parameters
temp_all_solid = cfg.PARAMS['temp_all_solid']
temp_all_liq = cfg.PARAMS['temp_all_liq']
temp_melt = cfg.PARAMS['temp_melt']
prcp_fac = cfg.PARAMS['prcp_scaling_factor']
default_grad = cfg.PARAMS['temp_default_gradient']
g_minmax = cfg.PARAMS['temp_local_gradient_bounds']
# Read file
igrad = None
with utils.ncDataset(gdir.get_filepath('climate_historical')) as nc:
# time
time = nc.variables['time']
time = netCDF4.num2date(time[:], time.units)
if time_range is not None:
p0 = np.where(time == time_range[0])[0]
try:
p0 = p0[0]
except IndexError:
raise MassBalanceCalibrationError('time_range[0] not found in '
'file')
p1 = np.where(time == time_range[1])[0]
try:
p1 = p1[0]
except IndexError:
raise MassBalanceCalibrationError('time_range[1] not found in '
'file')
else:
p0 = 0
p1 = len(time) - 1
time = time[p0:p1 + 1]
# Read timeseries
itemp = nc.variables['temp'][p0:p1 + 1]
iprcp = nc.variables['prcp'][p0:p1 + 1]
if 'gradient' in nc.variables:
igrad = nc.variables['gradient'][p0:p1 + 1]
# Security for stuff that can happen with local gradients
igrad = np.where(~np.isfinite(igrad), default_grad, igrad)
igrad = utils.clip_array(igrad, g_minmax[0], g_minmax[1])
ref_hgt = nc.ref_hgt
# Default gradient?
if igrad is None:
igrad = itemp * 0 + default_grad
# Correct precipitation
iprcp *= prcp_fac
# For each height pixel:
# Compute temp and tempformelt (temperature above melting threshold)
npix = len(heights)
grad_temp = np.atleast_2d(igrad).repeat(npix, 0)
grad_temp *= (heights.repeat(len(time)).reshape(grad_temp.shape) - ref_hgt)
temp2d = np.atleast_2d(itemp).repeat(npix, 0) + grad_temp
temp2dformelt = temp2d - temp_melt
temp2dformelt = utils.clip_min(temp2dformelt, 0)
# Compute solid precipitation from total precipitation
prcpsol = np.atleast_2d(iprcp).repeat(npix, 0)
fac = 1 - (temp2d - temp_all_solid) / (temp_all_liq - temp_all_solid)
fac = utils.clip_array(fac, 0, 1)
prcpsol = prcpsol * fac
return time, temp2dformelt, prcpsol
