def monthly_to_annual (data, time):
# Make sure we start at the beginning of a year
if time[0].month != 1:
print 'Error (monthly_to_annual): timeseries must start with January.'
sys.exit()
# Weighted average of each year, taking days per month into account
new_data = []
new_time = []
data_accum = 0
ndays = 0
for t in range(data.size):
ndays_curr = days_per_month(time[t].month, time[t].year)
data_accum += data[t]*ndays_curr
ndays += ndays_curr
if time[t].month == 12:
# End of the year
# Convert from integral to average
new_data.append(data_accum/ndays)
# Save the date at the beginning of the year
new_time.append(datetime.date(time[t].year, 1, 1))
# Reset the accumulation arrays
data_accum = 0
ndays = 0
return np.array(new_data), np.array(new_time)
def monthly_era5_files (file_head_in, start_year, end_year, file_head_out):
grid = ERA5Grid()
per_day = 24/6
for year in range(start_year, end_year+1):
print 'Processing year ' + str(year)
data = read_binary(file_head_in+'_'+str(year), [grid.nx, grid.ny], 'xyt')
data_monthly = np.empty([12, grid.ny, grid.nx])
t = 0
for month in range(12):
nt = days_per_month(month+1, year)*per_day
print 'Indices ' + str(t) + ' to ' + str(t+nt-1)
data_monthly[month,:] = np.mean(data[t:t+nt,:], axis=0)
t += nt
write_binary(data_monthly, file_head_out+'_'+str(year))
def average_monthly_files (input_files, output_file, t_start=0, t_end=None):
from nco import Nco
from nco.custom import Limit
if isinstance(input_files, str):
# Only one file
input_files = [input_files]
# Extract the first time record from the first file
# This will make a skeleton file with 1 time record and all the right metadata; later we will overwrite the values of all the time-dependent variables with the weighted time-averages.
print 'Initialising ' + output_file
nco = Nco()
nco.ncks(input=input_files[0], output=output_file, options=[Limit('time', t_start, t_start)])
# Get the starting date
time0 = netcdf_time(output_file)
year0 = time0[0].year
month0 = time0[0].month
# Find all the time-dependent variables
var_names = time_dependent_variables(output_file)
# Time-average each variable
id_out = nc.Dataset(output_file, 'a')
for var in var_names:
print 'Processing ' + var
# Reset time
year = year0
month = month0
# Set up accumulation array of the right dimension for this variable
shape = id_out.variables[var].shape[1:]
data = np.zeros(shape)
# Also accumulate total number of days
total_days = 0
# Loop over input files
for i in range(len(input_files)):
file_name = input_files[i]
print '...' + file_name
# Figure out how many time indices there are
id_in = nc.Dataset(file_name, 'r')
num_time = id_in.variables[var].shape[0]
# Choose which indices we will loop over: special cases for first and last files, if t_start or t_end are set
if i == 0:
t_start_curr = t_start
else:
t_start_curr = 0
if i == len(input_files)-1 and t_end is not None:
t_end_curr = t_end
else:
t_end_curr = num_time
# Now loop over time indices
for t in range(t_start_curr, t_end_curr):
# Integrate
ndays = days_per_month(month, year)
data += id_in.variables[var][t,:]*ndays
total_days += ndays
# Increment month (and year if needed)
month += 1
if month == 13:
month = 1
year += 1
id_in.close()
# Now convert from integral to average
data /= total_days
# Overwrite this variable in the output file
id_out.variables[var][0,:] = data
id_out.close()
def process_forcing_for_correction(source,
var,
mit_grid_dir,
out_file,
in_dir=None,
start_year=1979,
end_year=None):
# Set parameters based on source dataset
if source == 'ERA5':
if in_dir is None:
# Path on BAS servers
in_dir = '/data/oceans_input/processed_input_data/ERA5/'
file_head = 'ERA5_'
gtype = ['t', 't', 't', 't', 't']
elif source == 'UKESM':
if in_dir is None:
# Path on JASMIN
in_dir = '/badc/cmip6/data/CMIP6/CMIP/MOHC/UKESM1-0-LL/'
expt = 'historical'
ensemble_member = 'r1i1p1f2'
if var == 'wind':
var_names_in = ['uas', 'vas']
gtype = ['u', 'v']
elif var == 'thermo':
var_names_in = ['tas', 'huss', 'pr', 'ssrd', 'strd']
gtype = ['t', 't', 't', 't', 't']
days_per_year = 12 * 30
elif source == 'PACE':
if in_dir is None:
# Path on BAS servers
in_dir = '/data/oceans_input/processed_input_data/CESM/PACE_new/'
file_head = 'PACE_ens'
num_ens = 20
missing_ens = 13
if var == 'wind':
var_names_in = ['UBOT', 'VBOT']
monthly = [False, False]
elif var == 'thermo':
var_names_in = ['TREFHT', 'QBOT', 'PRECT', 'FSDS', 'FLDS']
monthly = [False, False, False, True, True]
gtype = ['t', 't', 't', 't', 't']
else:
print 'Error (process_forcing_for_correction): invalid source ' + source
sys.exit()
# Set parameters based on variable type
if var == 'wind':
var_names = ['uwind', 'vwind']
units = ['m/s', 'm/s']
elif var == 'thermo':
var_names = ['atemp', 'aqh', 'precip', 'swdown', 'lwdown']
units = ['degC', '1', 'm/s', 'W/m^2', 'W/m^2']
else:
print 'Error (process_forcing_for_correction): invalid var ' + var
sys.exit()
# Check end_year is defined
if end_year is None:
print 'Error (process_forcing_for_correction): must set end_year. Typically use 2014 for WSFRIS and 2013 for PACE.'
sys.exit()
mit_grid_dir = real_dir(mit_grid_dir)
in_dir = real_dir(in_dir)
print 'Building grids'
if source == 'ERA5':
forcing_grid = ERA5Grid()
elif source == 'UKESM':
forcing_grid = UKESMGrid()
elif source == 'PACE':
forcing_grid = PACEGrid()
mit_grid = Grid(mit_grid_dir)
ncfile = NCfile(out_file, mit_grid, 'xy')
# Loop over variables
for n in range(len(var_names)):
print 'Processing variable ' + var_names[n]
# Read the data, time-integrating as we go
data = None
num_time = 0
if source == 'ERA5':
# Loop over years
for year in range(start_year, end_year + 1):
file_path = in_dir + file_head + var_names[n] + '_' + str(year)
data_tmp = read_binary(file_path,
[forcing_grid.nx, forcing_grid.ny],
'xyt')
if data is None:
data = np.sum(data_tmp, axis=0)
else:
data += np.sum(data_tmp, axis=0)
num_time += data_tmp.shape[0]
elif source == ' UKESM':
in_files, start_years, end_years = find_cmip6_files(
in_dir, expt, ensemble_member, var_names_in[n], 'day')
# Loop over each file
for t in range(len(in_files)):
file_path = in_files[t]
print 'Processing ' + file_path
print 'Covers years ' + str(start_years[t]) + ' to ' + str(
end_years[t])
# Loop over years
t_start = 0 # Time index in file
t_end = t_start + days_per_year
for year in range(start_years[t], end_years[t] + 1):
if year >= start_year and year <= end_year:
print 'Processing ' + str(year)
# Read data
print 'Reading ' + str(year) + ' from indices ' + str(
t_start) + '-' + str(t_end)
data_tmp = read_netcdf(file_path,
var_names_in[n],
t_start=t_start,
t_end=t_end)
if data is None:
data = np.sum(data_tmp, axis=0)
else:
data += np.sum(data_tmp, axis=0)
num_time += days_per_year
# Update time range for next time
t_start = t_end
t_end = t_start + days_per_year
if var_names[n] == 'atemp':
# Convert from K to C
data -= temp_C2K
elif var_names[n] == 'precip':
# Convert from kg/m^2/s to m/s
data /= rho_fw
elif var_names[n] in ['swdown', 'lwdown']:
# Swap sign on radiation fluxes
data *= -1
elif source == 'PACE':
# Loop over years
for year in range(start_year, end_year + 1):
# Loop over ensemble members
data_tmp = None
num_ens_tmp = 0
for ens in range(1, num_ens + 1):
if ens == missing_ens:
continue
file_path = in_dir + file_head + str(ens).zfill(
2) + '_' + var_names_in[n] + '_' + str(year)
data_tmp_ens = read_binary(
file_path, [forcing_grid.nx, forcing_grid.ny], 'xyt')
if data_tmp is None:
data_tmp = data_tmp_ens
else:
data_tmp += data_tmp_ens
num_ens_tmp += 1
# Ensemble mean for this year
data_tmp /= num_ens_tmp
# Now accumulate time integral
if monthly[n]:
# Weighting for different number of days per month
for month in range(data_tmp.shape[0]):
# Get number of days per month with no leap years
ndays = days_per_month(month + 1, 1979)
data_tmp[month, :] *= ndays
num_time += ndays
else:
num_time += data_tmp.shape[0]
if data is None:
data = np.sum(data_tmp, axis=0)
else:
data += np.sum(data_tmp, axis=0)
# Now convert from time-integral to time-average
data /= num_time
forcing_lon, forcing_lat = forcing_grid.get_lon_lat(gtype=gtype[n],
dim=1)
# Get longitude in the range -180 to 180, then split and rearrange so it's monotonically increasing
forcing_lon = fix_lon_range(forcing_lon)
i_split = np.nonzero(forcing_lon < 0)[0][0]
forcing_lon = split_longitude(forcing_lon, i_split)
data = split_longitude(data, i_split)
# Now interpolate to MITgcm tracer grid
mit_lon, mit_lat = mit_grid.get_lon_lat(gtype='t', dim=1)
print 'Interpolating'
data_interp = interp_reg_xy(forcing_lon, forcing_lat, data, mit_lon,
mit_lat)
print 'Saving to ' + out_file
ncfile.add_variable(var_names[n], data_interp, 'xy', units=units[n])
ncfile.close()