def init_file(self, filename, time_units="seconds since 1970-01-01T00:00"):
"""
Initializes netCDF file for writing
Args:
filename: Name of the netCDF file
time_units: Units for the time variable in format "<time> since <date string>"
Returns:
Dataset object
"""
if os.access(filename, os.R_OK):
out_data = Dataset(filename, "r+")
else:
out_data = Dataset(filename, "w")
if len(self.data.shape) == 2:
for d, dim in enumerate(["y", "x"]):
out_data.createDimension(dim, self.data.shape[d])
else:
for d, dim in enumerate(["y", "x"]):
out_data.createDimension(dim, self.data.shape[d + 1])
out_data.createDimension("time", len(self.times))
time_var = out_data.createVariable("time", "i8", ("time", ))
time_var[:] = date2num(self.times.to_pydatetime(), time_units)
time_var.units = time_units
out_data.Conventions = "CF-1.6"
return out_data
def PutNC_3D(Var,
tim,
lat,
lon,
description='None',
symbol='Var',
unit='--',
fill=9.96921e+36,
filename='result.nc'):
"""
概要：
3次元(空間分布×時間変化)の気象変量をnetCDF形式のファイルで出力する関数。
書式：
PutNC_3D( Var, tim, lat, lon, description='None', symbol='Var', unit='--', fill=9.96921e+36, filename='result.nc' )
引数(必須)：
Var:内容を書き出す3次元配列変数。第0次元は日付、第1次元は緯度、第2次元は経度とする。
tim：配列Varがカバーする日付の配列。日付はPythonの日付オブジェクトで与える。Varの第0次元の要素数と一致していなくてはならない。
lat:配列Varの各行が位置する緯度値が格納されている配列。Varの第1次元の要素数と一致していなくてはならない。
lon:配列Varの各列が位置する経度値が格納されている配列。Varの第2次元の要素数と一致していなくてはならない。
引数(必要に応じ指定)：
description:データの正式名称などデータを説明する文。
symbol:データに対して用いる記号
unit:データの数値が従う単位
fill：無効値として取り扱う数値。デフォルト値は、9.96921e+36
filename：出力されるファイルの名前。デフォルト値は'result.nc'。
戻り値：なし。
"""
fh = Dataset(join(filename), "w")
fh.title = '3-D data crated by PutNC_3D function.'
fh.source = "Agro-Meteorological Grid Square Data System NIAES, NARO"
fh.Conventions = "None"
fh.creation_date = "Created " + dt.now().strftime("%Y/%m/%d %H:%M:%S JST")
fh.createDimension("time", len(tim))
fh.createDimension("lat", len(lat))
fh.createDimension("lon", len(lon))
nc_Var = fh.createVariable(symbol,
"f4", (
"time",
"lat",
"lon",
),
fill_value=fill)
nc_time = fh.createVariable("time",
"f8", ("time", ),
fill_value=9.969209968386869E36)
nc_lat = fh.createVariable("lat", "f4", ("lat", ))
nc_lon = fh.createVariable("lon", "f4", ("lon", ))
nc_time.calendar = "standard"
nc_time.units = "days since 1900-1-1 00:00:0.0"
nc_lat.long_name = "latitude"
nc_lat.units = "degrees_north"
nc_lon.long_name = "longitude"
nc_lon.units = "degrees_east"
nc_Var.long_name = description + '(' + symbol + ')'
nc_Var.units = unit
nc_Var[:, :, :] = Var
nc_time[:] = date2num(tim[:], units=nc_time.units)
nc_lat[:] = lat
nc_lon[:] = lon
fh.close()
def init_file(self, filename, time_units="seconds since 1970-01-01T00:00"):
"""
Initializes netCDF file for writing
Args:
filename: Name of the netCDF file
time_units: Units for the time variable in format "<time> since <date string>"
Returns:
Dataset object
"""
if os.access(filename, os.R_OK):
out_data = Dataset(filename, "r+")
else:
out_data = Dataset(filename, "w")
if len(self.data.shape) == 2:
for d, dim in enumerate(["y", "x"]):
out_data.createDimension(dim, self.data.shape[d])
else:
for d, dim in enumerate(["y", "x"]):
out_data.createDimension(dim, self.data.shape[d+1])
out_data.createDimension("time", len(self.times))
time_var = out_data.createVariable("time", "i8", ("time",))
time_var[:] = date2num(self.times.to_pydatetime(), time_units)
time_var.units = time_units
out_data.Conventions = "CF-1.6"
return out_data
def new(self, secs):
"""
Creates a new seNorge netCDF file.
Convention: Climate and Forecast (CF) version 1.4
@param secs: in seconds since 1970-01-01 00:00:00
"""
# create new file
rootgrp = Dataset(self.filename, 'w') # create new file using netcdf4
# rootgrp = netcdf_file(self.filename, 'w') # create new file using scipy.IO
# add root dimensions
rootgrp.createDimension('time', size=self.default_senorge_time)
rootgrp.createDimension('x', size=self.default_senorge_width)
rootgrp.createDimension('y', size=self.default_senorge_height)
# add root attributes
rootgrp.Conventions = "CF-1.4"
rootgrp.institution = "Norwegian Water Resources and Energy Directorate (NVE)"
rootgrp.source = ""
rootgrp.history = ""
rootgrp.references = ""
rootgrp.comment = "Data distributed via www.senorge.no"
self.rootgrp = rootgrp
# add coordinates
time = self.rootgrp.createVariable('time', 'f8', ('time', ))
time.units = 'seconds since 1970-01-01 00:00:00 +00:00'
time.long_name = 'time'
time.standard_name = 'time'
time[:] = secs
self._set_utm()
self._set_latlon()
def interpolate_to_netcdf(self,
in_lon,
in_lat,
out_path,
date_unit="seconds since 1970-01-01T00:00",
interp_type="spline"):
"""
Calls the interpolation function and then saves the MRMS data to a netCDF file. It will also create
separate directories for each variable if they are not already available.
"""
if interp_type == "spline":
out_data = self.interpolate_grid(in_lon, in_lat)
else:
out_data = self.max_neighbor(in_lon, in_lat)
if not os.access(out_path + self.variable, os.R_OK):
try:
os.mkdir(out_path + self.variable)
except OSError:
print(out_path + self.variable + " already created")
out_file = out_path + self.variable + "/" + "{0}_{1}_{2}.nc".format(
self.variable, self.start_date.strftime("%Y%m%d-%H:%M"),
self.end_date.strftime("%Y%m%d-%H:%M"))
out_obj = Dataset(out_file, "w")
out_obj.createDimension("time", out_data.shape[0])
out_obj.createDimension("y", out_data.shape[1])
out_obj.createDimension("x", out_data.shape[2])
data_var = out_obj.createVariable(self.variable,
"f4", ("time", "y", "x"),
zlib=True,
fill_value=-9999.0,
least_significant_digit=3)
data_var[:] = out_data
data_var.long_name = self.variable
data_var.coordinates = "latitude longitude"
if "MESH" in self.variable or "QPE" in self.variable:
data_var.units = "mm"
elif "Reflectivity" in self.variable:
data_var.units = "dBZ"
elif "Rotation" in self.variable:
data_var.units = "s-1"
else:
data_var.units = ""
out_lon = out_obj.createVariable("longitude",
"f4", ("y", "x"),
zlib=True)
out_lon[:] = in_lon
out_lon.units = "degrees_east"
out_lat = out_obj.createVariable("latitude",
"f4", ("y", "x"),
zlib=True)
out_lat[:] = in_lat
out_lat.units = "degrees_north"
dates = out_obj.createVariable("time", "i8", ("time", ), zlib=True)
dates[:] = np.round(date2num(self.all_dates.to_pydatetime(),
date_unit)).astype(np.int64)
dates.long_name = "Valid date"
dates.units = date_unit
out_obj.Conventions = "CF-1.6"
out_obj.close()
return
def new(self, secs):
"""
Creates a new seNorge netCDF file.
Convention: Climate and Forecast (CF) version 1.4
@param secs: in seconds since 1970-01-01 00:00:00
"""
# create new file
rootgrp = Dataset(self.filename, 'w') # create new file using netcdf4
# rootgrp = netcdf_file(self.filename, 'w') # create new file using scipy.IO
# add root dimensions
rootgrp.createDimension('time', size=self.default_senorge_time)
rootgrp.createDimension('x', size=self.default_senorge_width)
rootgrp.createDimension('y', size=self.default_senorge_height)
# add root attributes
rootgrp.Conventions = "CF-1.4"
rootgrp.institution = "Norwegian Water Resources and Energy Directorate (NVE)"
rootgrp.source = ""
rootgrp.history = ""
rootgrp.references = ""
rootgrp.comment = "Data distributed via www.senorge.no"
self.rootgrp = rootgrp
# add coordinates
time = self.rootgrp.createVariable('time', 'f8', ('time',))
time.units = 'seconds since 1970-01-01 00:00:00 +00:00'
time.long_name = 'time'
time.standard_name = 'time'
time[:] = secs
self._set_utm()
self._set_latlon()
def outputNC(output_file, nc4_file, total, interest_lon, interest_lat, time_steps, var_list, avg_dict):
print('Writing new nc4 file')
nc4_out = Dataset(output_file, 'w', format='NETCDF4')
#copying dimentions
for (name, dim) in nc4_file.dimensions.items():
nc4_out.createDimension(name, len(dim) if not dim.isunlimited() else None)
#copying variables
for (name, value) in nc4_file.variables.items():
nc4_vars = nc4_out.createVariable(name, value.datatype, value.dimensions)
nc4_vars.setncatts(nc4_file[name].__dict__)
if name in {"lat", "lon", "time"}:
nc4_out[name][:] = nc4_file[name][:]
dt = datetime.datetime.utcnow()
dt = dt.replace(microsecond=0)
nc4_out.Conventions='CF-1.6'
nc4_out.title=''
nc4_out.institution=''
nc4_out.history='date created: '+ dt.isoformat() +'+00:00'
nc4_out.references='https://github.com/c-h-david/shbaam/'
nc4_out.comment=''
nc4_out.featureType='timeSeries'
for var in var_list:
for i in range(total):
lon_index, lat_index = interest_lon[i][0],interest_lat[i][0]
long_term_mean = avg_dict[var][i]
for time in range(time_steps):
nc4_out[var][time,lat_index,lon_index] = nc4_file.variables[var][time,lat_index,lon_index] - long_term_mean
nc4_out.close()
print("Success -- creating nc4 file")
def CreateOutputFile(FileName,data):
# Create file
File = NetCDFFile(FileName,'w')
# Define some global attribs
File.Conventions='COARDS'
# Time is record dimension
File.createDimension('time',None)
var = File.createVariable('time','d',('time',))
var.long_name = 'time'
var.units = 'year'
# axes
try:
File.createDimension('level',data.File.dimensions['level'])
var = File.createVariable('level','f',('level',))
var.long_name = 'pressure level'
var.units = 'mb'
var[:] = data.File.variables['level'][:].astype('f')
except: pass
File.createDimension('lat',data.File.dimensions['lat'])
var = File.createVariable('lat','f',('lat',))
var.long_name = 'latitude'
var.units = 'degrees_north'
var[:] = data.File.variables['lat'][:]
File.createDimension('lon',data.File.dimensions['lon'])
var = File.createVariable('lon','f',('lon',))
var.long_name = 'longitude'
var.units = 'degrees_east'
var[:] = data.File.variables['lon'][:]
# create variables
var = File.createVariable(Field,'f',\
data.Field.dimensions)
var.long_name = data.Field.long_name
var.units = data.Field.units
return File
def writeNC(self):
"""
Save the data to the file that GNOME can read
"""
def create_nc_var(outfile,
name,
dimensions,
attdict,
dtype='f8',
zlib=False,
complevel=0):
nc = Dataset(outfile, 'a')
tmp = nc.createVariable(name,
dtype,
dimensions,
zlib=zlib,
complevel=complevel)
for aa in attdict.keys():
tmp.setncattr(aa, attdict[aa])
#nc.variables[name][:] = var
nc.close()
#### Write netcdf file ####
####create netcdf File####
nc = Dataset(self.outfile, 'w', format='NETCDF3_CLASSIC')
nc.file_type = 'Full_Grid'
nc.Conventions = 'COARDS'
nc.grid_type = 'curvilinear'
nc.set_fill_off()
#nc.Created = datetime.now().isoformat()
####Create dimensions####
nc.createDimension('x', self.x)
nc.createDimension('y', self.y)
nc.createDimension('time', None) ##unlimited dimension
nc.close()
####adding variables####
create_nc_var(self.outfile, 'time', ('time'),
{'units': 'seconds since 1970-01-01 00:00:00'})
create_nc_var(self.outfile,'lon',('y','x'),{'long_name':'Longitude',\
'units':'degrees_east','standard_name':'longitude'})
create_nc_var(self.outfile,'lat',('y','x'),{'long_name':'Latitude',\
'units':'degrees_north','standard_name':'latitude'})
create_nc_var(self.outfile,'air_u',('time','y','x'),{'long_name':'Eastward Air Velocity',\
'units':'m/s','missing_value':'-99999.0','standard_name':'eastward_wind'})
create_nc_var(self.outfile,'air_v',('time','y','x'),{'long_name':'Northward Air Velocity',\
'units':'m/s','missing_value':'-99999.0','standard_name':'northward_wind'})
time_new = SecondsSince(self.t, basetime=datetime(1970, 1, 1))
######Now writting the variables######
nc = Dataset(self.outfile, 'a')
nc.variables['time'][:] = time_new
nc.variables['lon'][:] = self.lon
nc.variables['lat'][:] = self.lat
nc.variables['air_u'][:] = self.air_u
nc.variables['air_v'][:] = self.air_v
print "Generating NCEP wind file %s for GNOME!!!\n" % self.outfile
nc.close()
def _set_global_attributes(ncfile: nc.Dataset,
path: Path) -> None: # type: ignore[import]
ncfile.Conventions = "CF-1.8 UGRID-1.0"
ncfile.title = "Delft3D-FM 1D2D network for model " + path.name.rstrip(
"_net.nc")
ncfile.source = f"HYDROLIB-core v.{__version__}, D-HyDAMO, model {path.name.rstrip('_net.nc')}"
ncfile.history = f"Created on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} by {Path(__file__).name}."
ncfile.institution = "Deltares/HKV"
ncfile.references = "https://github.com/openearth/delft3dfmpy/; https://www.deltares.nl; https://www.hkv.nl"
def writeCMIP5File(modelName, scenario, myvarname, lon, lat, time, mydata,
mydataanomaly, outfilename):
myformat = 'NETCDF3_CLASSIC'
if os.path.exists(outfilename):
os.remove(outfilename)
print("Results written to netcdf file: %s" % (outfilename))
if myvarname == "sic": myvar = "SIC"
f1 = Dataset(outfilename, mode='w', format=myformat)
f1.title = "IPCC AR5 %s" % (myvar)
f1.description = "IPCC AR5 running averages of %s for model %s for scenario %s" % (
myvar, modelName, scenario)
f1.history = "Created " + str(datetime.now())
f1.source = "Trond Kristiansen ([email protected])"
f1.type = "File in NetCDF3 format created using iceExtract.py"
f1.Conventions = "CF-1.0"
"""Define dimensions"""
f1.createDimension('x', len(lon))
f1.createDimension('y', len(lat))
f1.createDimension('time', None)
vnc = f1.createVariable('longitude', 'd', ('x', ), zlib=False)
vnc.long_name = 'Longitude'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:] = lon
vnc = f1.createVariable('latitude', 'd', ('y', ), zlib=False)
vnc.long_name = 'Latitude'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:] = lat
v_time = f1.createVariable('time', 'd', ('time', ), zlib=False)
v_time.long_name = 'Years'
v_time.units = 'Years'
v_time.field = 'time, scalar, series'
v_time[:] = time
v_temp = f1.createVariable('SIC', 'd', (
'time',
'y',
'x',
), zlib=False)
v_temp.long_name = "Sea-ice area fraction (%)"
v_temp.units = "%"
v_temp.time = "time"
v_temp.field = "SIC, scalar, series"
v_temp.missing_value = 1e20
if myvarname == 'sic':
f1.variables['SIC'][:, :, :] = mydata
f1.close()
def _create_global_attributes(f: netCDF4.Dataset, global_attr: dict,
level: int):
f.Conventions = 'CF-1.7'
f.year, f.month, f.day = _get_measurement_date(f)
f.uuid = uuid.uuid4().hex
f.history = f"Radar file created: {utils.get_current_time()}"
f.level = level
if global_attr and isinstance(global_attr, dict):
for key, value in global_attr.items():
setattr(f, key, value)
def writeCMIP5File(modelName,scenario,myvarname,lon,lat,time,mydata,mydataanomaly,outfilename):
myformat='NETCDF3_CLASSIC'
if os.path.exists(outfilename):
os.remove(outfilename)
print "Results written to netcdf file: %s"%(outfilename)
if myvarname=="sic": myvar="SIC"
f1 = Dataset(outfilename, mode='w', format=myformat)
f1.title = "IPCC AR5 %s"%(myvar)
f1.description = "IPCC AR5 running averages of %s for model %s for scenario %s"%(myvar,modelName,scenario)
f1.history = "Created " + str(datetime.now())
f1.source = "Trond Kristiansen ([email protected])"
f1.type = "File in NetCDF3 format created using iceExtract.py"
f1.Conventions = "CF-1.0"
"""Define dimensions"""
f1.createDimension('x', len(lon))
f1.createDimension('y', len(lat))
f1.createDimension('time', None)
vnc = f1.createVariable('longitude', 'd', ('x',),zlib=False)
vnc.long_name = 'Longitude'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:] = lon
vnc = f1.createVariable('latitude', 'd', ('y',),zlib=False)
vnc.long_name = 'Latitude'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:] = lat
v_time = f1.createVariable('time', 'd', ('time',),zlib=False)
v_time.long_name = 'Years'
v_time.units = 'Years'
v_time.field = 'time, scalar, series'
v_time[:]=time
v_temp=f1.createVariable('SIC', 'd', ('time', 'y', 'x',),zlib=False)
v_temp.long_name = "Sea-ice area fraction (%)"
v_temp.units = "%"
v_temp.time = "time"
v_temp.field="SIC, scalar, series"
v_temp.missing_value = 1e20
if myvarname=='sic':
f1.variables['SIC'][:,:,:] = mydata
f1.close()
def PutNC_Map(Var,
lat,
lon,
description='Variable',
symbol='Var',
unit='--',
fill=9.96921e+36,
filename='result.nc'):
"""
概要：
2次元(空間分布)の気象変量をnetCDF形式のファイルで出力する関数。
書式：
PutNC_Map( Var, lat, lon, description='Variable', symbol='Var', unit='--', fill=9.96921e+36, filename='result.nc')
引数(必須)：
Var:内容を書き出す配列変数。
lat:配列Varの各行が位置する緯度値が格納されている配列。Varの第1次元の要素数と一致していなくてはならない。
lon:配列Varの各列が位置する経度値が格納されている配列。Varの第2次元の要素数と一致していなくてはならない。
引数(必要に応じ指定)：
description:データの正式名称などデータを説明する文。
symbol:データに対して用いる記号
unit:データの数値が従う単位
fill：無効値として取り扱う数値。デフォルト値は、9.96921e+36
filename：出力されるファイルの名前。デフォルト値は'result.nc'。
戻り値：なし。
"""
#----------------------------------------------------------------------------------
fh = Dataset(filename, "w")
fh.title = 'Map data crated by PutNC_Map function.'
fh.source = "Agro-Meteorological Grid Square Data System NIAES, NARO"
fh.Conventions = "None"
fh.creation_date = "Created " + dt.now().strftime("%Y/%m/%d %H:%M:%S JST")
fh.createDimension("lat", len(lat))
fh.createDimension("lon", len(lon))
nc_data = fh.createVariable(symbol,
"f4", (
"lat",
"lon",
),
fill_value=fill)
nc_lat = fh.createVariable("lat", "f4", ("lat", ))
nc_lon = fh.createVariable("lon", "f4", ("lon", ))
nc_lat.long_name = "latitude"
nc_lat.units = "degrees_north"
nc_lon.long_name = "longitude"
nc_lon.units = "degrees_east"
nc_data.long_name = description + '(' + symbol + ')'
nc_data.units = unit
nc_data[:, :] = Var
nc_lat[:] = lat
nc_lon[:] = lon
fh.close()
def tamoc_nc_file(fname, title, summary, source):
"""
Write the header meta data to an netCDF file for a TAMOC output
The TAMOC suite stores its output by detaul in a netCDF dataset file.
This function writes the standard TAMOC metadata to the header of the
netCDF file.
Parameters
----------
fname : str
File name of the file to write
title: str
String stating the TAMOC module where the data originated and the
type of data contained.
summary : str
String summarizing what is contained in the dataset or information
needed to interpret the dataset
source : str
String describing the source of the data in the dataset or of related
datasets
Returns
-------
nc : `netCDF4.Dataset` object
The `netCDF4.Dataset` object containing the open netCDF4 file where
the data should be stored.
"""
# Create the netCDF dataset object
nc = Dataset(fname, 'w', format='NETCDF4_CLASSIC')
# Write the netCDF header data for a TAMOC suite output
nc.Conventions = 'TAMOC Modeling Suite Output File'
nc.Metadata_Conventions = 'TAMOC Python Model'
nc.featureType = 'profile'
nc.cdm_data_type = 'Profile'
nc.nodc_template_version = \
'NODC_NetCDF_Profile_Orthogonal_Template_v1.0'
nc.title = title
nc.summary = summary
nc.source = source
nc.creator_url = 'http://github.com/socolofs/tamoc'
nc.date_created = datetime.today().isoformat(' ')
nc.date_modified = datetime.today().isoformat(' ')
nc.history = 'Creation'
# Return the netCDF dataset
return nc
def tamoc_nc_file(fname, title, summary, source):
"""
Write the header meta data to an netCDF file for a TAMOC output
The TAMOC suite stores its output by detaul in a netCDF dataset file.
This function writes the standard TAMOC metadata to the header of the
netCDF file.
Parameters
----------
fname : str
File name of the file to write
title: str
String stating the TAMOC module where the data originated and the
type of data contained.
summary : str
String summarizing what is contained in the dataset or information
needed to interpret the dataset
source : str
String describing the source of the data in the dataset or of related
datasets
Returns
-------
nc : `netCDF4.Dataset` object
The `netCDF4.Dataset` object containing the open netCDF4 file where
the data should be stored.
"""
# Create the netCDF dataset object
nc = Dataset(fname, 'w', format='NETCDF4_CLASSIC')
# Write the netCDF header data for a TAMOC suite output
nc.Conventions = 'TAMOC Modeling Suite Output File'
nc.Metadata_Conventions = 'TAMOC Python Model'
nc.featureType = 'profile'
nc.cdm_data_type = 'Profile'
nc.nodc_template_version = \
'NODC_NetCDF_Profile_Orthogonal_Template_v1.0'
nc.title = title
nc.summary = summary
nc.source = source
nc.creator_url = 'http://github.com/socolofs/tamoc'
nc.date_created = datetime.today().isoformat(' ')
nc.date_modified = datetime.today().isoformat(' ')
nc.history = 'Creation'
# Return the netCDF dataset
return nc
def interpolate_to_netcdf(self, in_lon, in_lat, out_path, date_unit="seconds since 1970-01-01T00:00",
interp_type="spline"):
"""
Calls the interpolation function and then saves the MRMS data to a netCDF file. It will also create
separate directories for each variable if they are not already available.
"""
if interp_type == "spline":
out_data = self.interpolate_grid(in_lon, in_lat)
else:
out_data = self.max_neighbor(in_lon, in_lat)
if not os.access(out_path + self.variable, os.R_OK):
try:
os.mkdir(out_path + self.variable)
except OSError:
print(out_path + self.variable + " already created")
out_file = out_path + self.variable + "/" + "{0}_{1}_{2}.nc".format(self.variable,
self.start_date.strftime("%Y%m%d-%H:%M"),
self.end_date.strftime("%Y%m%d-%H:%M"))
out_obj = Dataset(out_file, "w")
out_obj.createDimension("time", out_data.shape[0])
out_obj.createDimension("y", out_data.shape[1])
out_obj.createDimension("x", out_data.shape[2])
data_var = out_obj.createVariable(self.variable, "f4", ("time", "y", "x"), zlib=True,
fill_value=-9999.0,
least_significant_digit=3)
data_var[:] = out_data
data_var.long_name = self.variable
data_var.coordinates = "latitude longitude"
if "MESH" in self.variable or "QPE" in self.variable:
data_var.units = "mm"
elif "Reflectivity" in self.variable:
data_var.units = "dBZ"
elif "Rotation" in self.variable:
data_var.units = "s-1"
else:
data_var.units = ""
out_lon = out_obj.createVariable("longitude", "f4", ("y", "x"), zlib=True)
out_lon[:] = in_lon
out_lon.units = "degrees_east"
out_lat = out_obj.createVariable("latitude", "f4", ("y", "x"), zlib=True)
out_lat[:] = in_lat
out_lat.units = "degrees_north"
dates = out_obj.createVariable("time", "i8", ("time",), zlib=True)
dates[:] = np.round(date2num(self.all_dates.to_pydatetime(), date_unit)).astype(np.int64)
dates.long_name = "Valid date"
dates.units = date_unit
out_obj.Conventions="CF-1.6"
out_obj.close()
return
def init(cls, ds: Dataset) -> bool:
# CF convention
try:
_ = ds.Conventions
except AttributeError:
cf = 'CF-1.6'
ds.Conventions = cf
# time coordinate
try:
_ = ds.variables["time"]
except KeyError:
tdim = ds.createDimension('time', None)
time = ds.createVariable('time', np.float64, (tdim.name, ))
time.units = 'milliseconds since 1970-01-01T00:00:00'
time.calendar = 'gregorian'
# version
try:
version = ds.version
if version > lib_info.lib_version:
raise RuntimeError("Project has a future version: %s" %
version)
if version < lib_info.lib_version:
raise RuntimeError("Project has a path version: %s" % version)
except AttributeError:
ds.version = lib_info.lib_version
# created
try:
_ = ds.created
except AttributeError:
ds.created = date2num(datetime.utcnow(),
ds.variables["time"].units,
ds.variables["time"].calendar)
# modified
try:
_ = ds.modified
except AttributeError:
ds.modified = date2num(datetime.utcnow(),
ds.variables["time"].units,
ds.variables["time"].calendar)
ds.sync()
return True
def create_netcdf(self, path):
# File format:
outformat = "NETCDF3_CLASSIC" #"NETCDF4"
# File where we going to write
ncfile = Dataset(path, 'w', format=outformat)
# global attributes
ncfile.Conventions = "CF-1.8 UGRID-1.0"
ncfile.history = "Created on {} D-Flow 1D, D-Flow FM".format(
datetime.now())
ncfile.institution = "Deltares"
ncfile.reference = "http://www.deltares.nl"
ncfile.source = "Python script to prepare HyDAMO import"
return ncfile
def setup_netcdf_dataset(config, grid, crs):
"""Create NetCDF file, add required dimensions and coordinate variables"""
nc = Dataset(config['output_file'], 'w', format='NETCDF4')
nc.title = "Input data for NanoFASE model"
nc.Conventions = 'CF-1.6'
crs_var = nc.createVariable('crs', 'i4')
crs_var.spatial_ref = crs.to_wkt(
) # QGIS/ArcGIS recognises spatial_ref to define CRS
crs_var.crs_wkt = crs.to_wkt(
) # Latest CF conventions say crs_wkt can be used
# Time dimensions and coordinate variable
t_dim = nc.createDimension('t', None)
t = nc.createVariable('t', 'i4', ('t', ))
t.units = "seconds since {0} 00:00:00".format(config['time']['start_date'])
t.standard_name = 'time'
t.calendar = 'gregorian'
t[:] = [
i * int(config['time']['dt']) for i in range(int(config['time']['n']))
]
# x dimension and coordinate variable
x_dim = nc.createDimension('x', grid.width)
x = nc.createVariable('x', 'f4', ('x', ))
x.units = 'm'
x.standard_name = 'projection_x_coordinate'
x.axis = 'X'
x[:] = [grid.bounds.left + i * grid.res[0] for i in range(grid.width)]
# y dimension and coordinate variable
y_dim = nc.createDimension('y', grid.height)
y = nc.createVariable('y', 'f4', ('y', ))
y.units = 'm'
y.standard_name = 'projection_y_coordinate'
y.axis = 'Y'
y[:] = [grid.bounds.top - i * grid.res[1] for i in range(grid.height)]
# Add the flow direction
flow_dir = grid.read(
1, masked=True) # Get the flow direction array from the raster
grid_mask = np.ma.getmask(
flow_dir
) # Use the extent of the flow direction array to create a mask for all other data
nc_var = nc.createVariable('flow_dir', 'i4', ('y', 'x'))
nc_var.long_name = 'flow direction of water in grid cell'
nc_var[:] = flow_dir
# Route the reaches using the flow direction
routed_reaches = routing(flow_dir)
# Return the NetCDF file
return nc, grid_mask
def new(self, secs):
"""
Creates a new seNorge netCDF file.
Convention: Climate and Forecast (CF) version 1.4
:Parameters:
- secs: in seconds since 1970-01-01 00:00:00
"""
# create new file
try:
rootgrp = Dataset(self.filename, 'w', format='NETCDF3_CLASSIC')
# add root dimensions
rootgrp.createDimension('time', size=self.default_senorge_time)
rootgrp.createDimension('x', size=default_senorge_width)
rootgrp.createDimension('y', size=default_senorge_height)
except TypeError:
rootgrp = Dataset(self.filename, 'w')
# add root dimensions
rootgrp.createDimension('time', self.default_senorge_time)
rootgrp.createDimension('x', default_senorge_width)
rootgrp.createDimension('y', default_senorge_height)
# add root attributes
rootgrp.Conventions = "CF-1.4"
rootgrp.institution = "Norwegian Water Resources and Energy Directorate (NVE)"
rootgrp.source = ""
rootgrp.history = "%s created" % time.ctime(time.time())
rootgrp.references = ""
rootgrp.comment = "Data distributed via www.senorge.no"
self.rootgrp = rootgrp
# add coordinates
try:
times = self.rootgrp.createVariable('time', 'f8', ('time',))
except TypeError:
times = self.rootgrp.createVariable('time', 'f', ('time',))
times.units = 'seconds since 1970-01-01 00:00:00 +00:00'
times.long_name = 'time'
times.standard_name = 'time'
times.axis = 'T'
times.calendar = 'standard'
times[:] = secs
self._set_utm()
self._set_latlon()
def write_depth_meridional(ofile, data, data_name, lat, depth):
f1 = Dataset(ofile, 'w', clobber=True,
format='NETCDF4') #'w' stands for write
ys = f1.createDimension('y', data.shape[1])
zs = f1.createDimension('z', data.shape[0])
meris = f1.createVariable('lat', np.float64, ('z', 'y'))
depths = f1.createVariable('depth', np.float64, ('z', 'y'))
data1 = f1.createVariable(data_name, np.float64, ('z', 'y'))
meris[:, :] = lat.copy()
depths[:, ] = depth.copy()
data1[:, :] = data.copy()
#lons[:] = np.arange(48, 51.1, 0.1)
f1.Conventions = 'CF-1.0'
f1.close()
def write_nc_file(daily_results, filename, nc, anom_mode=False):
#Grab every 4th time value to represent daily
daily_time_var = nc.variables['time'][::4]
nc_out = Dataset(filename, mode='w', format='NETCDF4')
nc_out.createDimension('lon', LONS)
nc_out.createDimension('lat', LATS)
nc_out.createDimension('time', None) #UNLIMITED
nc_out.createDimension('month', MONTHS_YEAR)
nc_out.title = ''
nc_out.institution = ''
nc_out.project = ''
nc_out.contact = '*****@*****.**'
nc_out.Conventions = "CF-1.6"
longitude = nc_out.createVariable('lon', 'f8', ('lon', ))
longitude.standard_name = 'longitude'
longitude.long_name = 'longitude'
longitude.units = 'degrees_east'
longitude.modulo = 360.0
longitude.axis = 'X'
longitude[:] = np.arange(0, 360.0, 2.0)
latitude = nc_out.createVariable('lat', 'f8', ('lat', ))
latitude.standard_name = 'latitude'
latitude.long_name = 'latitude'
latitude.units = 'degrees_north'
latitude.axis = 'Y'
latitude[:] = np.arange(-90.0, 92.0, 2.0)
time = nc_out.createVariable('time', 'f8', ('time', ))
time.units = 'hours since 1-1-1 0:0:0'
time.calendar = 'standard' #Gregorian
time[:] = daily_time_var
if anom_mode:
daily_mean = nc_out.createVariable('daily_anom', 'f8',
('time', 'lat', 'lon'))
daily_mean.long_name = 'z500 daily anomaly vs 1981-2010'
else:
daily_mean = nc_out.createVariable('daily_mean', 'f8',
('time', 'lat', 'lon'))
daily_mean.long_name = 'z500 daily mean'
daily_mean[:] = daily_results
nc_out.close()
def generate_nc(parser_context):
parser = XLSParser()
with open(parser_context.filepath, 'r') as f:
doc = f.read()
info = parser.extract_worksheets(doc)
nccl = info[parser_context.worksheet]
#header_line = 3
#columns = nccl[header_line]
#data_range = (4, 66)
data_rows = nccl[parser_context.data_range[0]:parser_context.data_range[1]]
print 'Generating',parser_context.output_file
nc = Dataset(parser_context.output_file, 'w')
nc.createDimension('time', len(data_rows)*12)
nc.GDAL = "GDAL 1.9.2, released 2012/10/08"
nc.history = "Created dynamically in IPython Notebook 2013-11-14"
nc.title = nccl[0][0]
nc.summary = nccl[1][0]
nc.naming_authority = 'GLOS'
nc.source = 'GLERL'
nc.standard_name_vocabulary = "http://www.cgd.ucar.edu/cms/eaton/cf-metadata/standard_name.html"
nc.project = 'GLOS'
nc.Conventions = "CF-1.6"
time = nc.createVariable('time', 'f8', ('time',))
time.standard_name = 'time'
time.units = 'seconds since 1970-01-01'
time.long_name = 'Time'
time.axis = 'T'
precip = nc.createVariable(parser_context.variable, 'f8', ('time',), fill_value=parser_context.fill_value)
#precip.standard_name = 'precipitation_amount'
precip.standard_name = parser_context.standard_name
precip.units = parser_context.units
for i,row in enumerate(data_rows):
for j in xrange(12):
the_date = datetime(row[0], j+1, 1)
timestamp = calendar.timegm(the_date.utctimetuple())
time[i*12 + j] = timestamp
try:
value = float(row[j+1])
except ValueError:
continue
except TypeError:
continue
precip[i*12 + j] = value
nc.close()
def create_netcdf(self, path, version):
# File format:
outformat = "NETCDF3_CLASSIC" #"NETCDF4"
# File where we going to write
ncfile = Dataset(path, 'w', format=outformat)
# global attributes
ncfile.Conventions = "CF-1.8 UGRID-1.0"
ncfile.title = 'Delft3D-FM 1D2D network for model ' + os.path.split(
path)[-1].rstrip('_net.nc')
ncfile.source = f"delft3dfmpy v.{version['number']}, D-HyDAMO, model {os.path.split(path)[-1].rstrip('_net.nc')}"
ncfile.history = f"Created on {version['date']} by {os.path.split(__file__)[-1]}."
ncfile.institution = "Deltares/HKV"
ncfile.references = "https://github.com/openearth/delft3dfmpy/; https://www.deltares.nl; https://www.hkv.nl"
ncfile.comment = f"Tested and compatible with D-Flow FM {version['dfm_version']}, DIMRset {version['dimr_version']} and D-HYDRO suite 1D2D {version['suite_version']}"
return ncfile
def write_nc_file(daily_results, filename, nc, anom_mode=False):
#Grab every 4th time value to represent daily
daily_time_var = nc.variables['time'][::4]
nc_out = Dataset(filename, mode='w', format='NETCDF4')
nc_out.createDimension('lon', LONS)
nc_out.createDimension('lat', LATS)
nc_out.createDimension('time', None) #UNLIMITED
nc_out.createDimension('month', MONTHS_YEAR)
nc_out.title = ''
nc_out.institution = ''
nc_out.project = ''
nc_out.contact = '*****@*****.**'
nc_out.Conventions = "CF-1.6"
longitude = nc_out.createVariable('lon', 'f8', ('lon',))
longitude.standard_name = 'longitude'
longitude.long_name = 'longitude'
longitude.units = 'degrees_east'
longitude.modulo = 360.0
longitude.axis = 'X'
longitude[:] = np.arange(0, 360.0, 2.0)
latitude = nc_out.createVariable('lat', 'f8', ('lat',))
latitude.standard_name = 'latitude'
latitude.long_name = 'latitude'
latitude.units = 'degrees_north'
latitude.axis = 'Y'
latitude[:] = np.arange(-90.0, 92.0, 2.0)
time = nc_out.createVariable('time', 'f8', ('time',))
time.units = 'hours since 1-1-1 0:0:0'
time.calendar = 'standard' #Gregorian
time[:] = daily_time_var
if anom_mode:
daily_mean = nc_out.createVariable('daily_anom', 'f8', ('time', 'lat', 'lon'))
daily_mean.long_name = 'z500 daily anomaly vs 1981-2010'
else:
daily_mean = nc_out.createVariable('daily_mean', 'f8', ('time', 'lat', 'lon'))
daily_mean.long_name = 'z500 daily mean'
daily_mean[:] = daily_results
nc_out.close()
def prepare_file(fname, x, y):
print " preparing file '%s'..." % fname
nc = NC(fname, "w", format="NETCDF3_CLASSIC")
nc.set_fill_off()
nc.createDimension("time", None)
nc.createDimension("x", size=x.size)
nc.createDimension("y", size=y.size)
t_var = nc.createVariable("time", 'f', dimensions=("time", ))
x_var = nc.createVariable("x", 'f', dimensions=("x", ))
x_var[:] = x
y_var = nc.createVariable("y", 'f', dimensions=("y", ))
y_var[:] = y
# put dimensions metadata in a dictionary:
# name : (unit, long_name, standard_name)
attributes = {
"x":
("m", "X-coordinate in Cartesian system", "projection_x_coordinate"),
"y":
("m", "Y-coordinate in Cartesian system", "projection_y_coordinate"),
"time": ("years since 2004-1-1", "time", "time")
}
for each in list(attributes.keys()):
var = nc.variables[each]
var.units = attributes[each][0]
var.long_name = attributes[each][1]
var.standard_name = attributes[each][2]
ps = nc.createVariable("mapping", 'b')
ps.grid_mapping_name = "polar_stereographic"
ps.straight_vertical_longitude_from_pole = -39.0
ps.latitude_of_projection_origin = 90.0
ps.standard_parallel = 71.0
nc.Conventions = "CF-1.3"
nc.createDimension("nv", size=2)
t_bounds = nc.createVariable('time_bounds', 'f4', ('time', 'nv'))
nc.variables['time'].bounds = 'time_bounds'
return (nc, t_var, t_bounds)
def write_etopo_cache(arcmins, version, lons, lats, topo):
log.debug('writing etopo cache %d %s %s %s' % (arcmins, lons, lats, topo))
etopo_path = os.path.join(etopo_dir, etopo_filename(arcmins, version))
toponc = Dataset(etopo_path, 'w')
dim_x = toponc.createDimension('x', lons.size)
dim_y = toponc.createDimension('y', lats.size)
var_lons = toponc.createVariable('x', 'f8', ('x', ))
var_lons.long_name = 'Longitude'
var_lons.actual_range = [-180., 180.]
var_lons.units = 'degrees'
var_lats = toponc.createVariable('y', 'f8', ('y', ))
var_lats.long_name = 'Latitude'
var_lats.actual_range = [-90., 90.]
var_lats.units = 'degrees'
var_topo = toponc.createVariable('z',
'i4', (
'y',
'x',
),
fill_value=-2**31)
var_topo.long_name = 'z'
var_topo.actual_range = [topo.min(), topo.max()]
toponc.Conventions = 'COARDS/CF-1.0'
toponc.title = etopo_path
toponc.history = 'downsampled from ETOPO1 by libcchdo'
toponc.GMT_version = '4.4.0'
toponc.node_offset = 0
try:
log.info('Writing %s' % etopo_path)
var_lons[:] = lons
var_lats[:] = lats
var_topo[:] = topo
finally:
toponc.close()
def write_3D(ofile, data, data_name, lat, lon, depth):
f1 = Dataset(ofile, 'w', clobber=True,
format='NETCDF4') #'w' stands for write
f1.createDimension('x', data.shape[2])
f1.createDimension('y', data.shape[1])
f1.createDimension('depth', data.shape[0])
lato = f1.createVariable('lat', np.float64, ('y', 'x'))
lono = f1.createVariable('lon', np.float64, ('y', 'x'))
deptho = f1.createVariable('depth', np.float64, ('depth', ))
data1 = f1.createVariable(data_name,
np.float64, ('depth', 'y', 'x'),
fill_value=9e33)
data1.coordinates = "lat lon"
lato[:] = lat.copy()
lono[:] = lon.copy()
deptho[:] = depth.copy()
data1[:] = data.copy()
#lons[:] = np.arange(48, 51.1, 0.1)
f1.Conventions = 'CF-1.0'
f1.close()
def create_netcdf_file(filename, lon, lat, T, file_sections):
T = T - 1
root_grp = Dataset(filename, 'w', format='NETCDF4', clobber=True)
root_grp.Conventions = 'CF-1.0'
# dimensions
root_grp.createDimension('time', len(T))
root_grp.createDimension('nx_grid', lon.shape[1])
root_grp.createDimension('ny_grid', lon.shape[0])
# variables
times = root_grp.createVariable('time', 'f8', ('time', ))
base_date = np.double(num2date(T[0]).year), np.double(
num2date(T[0]).month), np.double(num2date(T[0]).day), np.double(
num2date(T[0]).hour), np.double(num2date(T[0]).minute), np.double(
num2date(T[0]).second)
times.base_date = base_date
latitudes = root_grp.createVariable('lat', 'f4', (
'ny_grid',
'nx_grid',
))
longitudes = root_grp.createVariable('lon', 'f4', (
'ny_grid',
'nx_grid',
))
## add the main var
times[:] = np.ceil(abs(T - T[0]) * 1000) / 1000
latitudes[:, :] = lat
longitudes[:, :] = lon
## save the rest
temp = {}
for m in file_sections:
temp[m] = root_grp.createVariable(m, 'f4', (
'time',
'ny_grid',
'nx_grid',
))
return temp, root_grp
def createfile(filename):
''' Creates the netCDF file to then be opened in field2nc.
Needs changing when extracting a different field #**# indicate
that there is something that needs changing.
'''
print filename
f = Dataset(filename,'w')
zres = 180 #**#
latres = 324 #**#
lonres = 432 #**#
# Create dimensions
time = f.createDimension('time',None)
z_hybrid_height = f.createDimension('z_hybrid_height',zres)
latitude = f.createDimension('latitude',latres)
longitude = f.createDimension('longitude',lonres)
# Create variables (added s on the end to differentiate between dimensions
# and variables)
times = f.createVariable('time','f4',('time',),zlib=True)
z_hybrid_heights = f.createVariable('z_hybrid_height','f4',
('z_hybrid_height',),zlib=True)
latitudes = f.createVariable('latitude','f4',('latitude',),zlib=True)
longitudes = f.createVariable('longitude','f4',('longitude',),zlib=True)
v = f.createVariable('u','f4',('time','z_hybrid_height','latitude',
'longitude',),zlib=True) #**#
# Add in attributes
f.Conventions = 'CF-1.6'
times.units = 'hours since 1981-09-01 00:00:00'
times.standard_name = 'time'
times.calendar = '360_day'
times.axis = 'T'
z_hybrid_heights.positive = 'up'
z_hybrid_heights.long_name = 'atmosphere hybrid height coordinate'
z_hybrid_heights.standard_name = 'atmosphere_hybrid_height_coordinate'
z_hybrid_heights.units = 'm'
z_hybrid_heights.axis = 'Z'
latitudes.bounds = 'bounds_latitude'
latitudes.units = 'degrees_north'
latitudes.standard_name = 'latitude'
latitudes.point_spacing = 'even'
latitudes.axis = 'Y'
longitudes.bounds = 'bounds_longitude'
longitudes.modulo = 360.
longitudes.point_spacing = 'even'
longitudes.standard_name = 'longitude'
longitudes.units = 'degrees_east'
longitudes.axis = 'X'
longitudes.topology = 'circular'
#**#
v.lookup_source = 'defaults (cdunifpp V0.13)'
v.standard_name = 'eastward_wind'
v.long_name = 'U COMPONENT OF WIND AFTER TIMESTEP'
v.units = 'm s-1'
v.missing_value = -1.073742e+09
#**#
# Add in values of lat, lon and height
fieldfile = 'xjleha.pj'+filename[-13:-5] #**#
f2 = cdms2.open('/group_workspaces/jasmin/hiresgw/xjleh/'+fieldfile)#**#
var = f2.getVariables()
v2 = var[9]#**#
z2 = f2.getVariables()[0]
zvals = z2.domain[0][0][:]
# Check the length of the latitude dimension
if v2.shape[2] == 324:
latvals = np.linspace(-90+90./324,90-90./324,324)
elif v2.shape[2] == 325:
latvals = np.linspace(-90,90,325)
else: raise ValueError('Unhandled latitude dimension')
# Check the length of the latitude dimension
if v2.shape[3] == 432 and v2.shape[2] == 324:
lonvals = np.linspace(0,360-360./432,432)
elif v2.shape[3] == 432 and v2.shape[2] == 325:
lonvals = np.linspace(360./(432*2),360.-360./(432*2),432)
else: raise ValueError('Unhandled longitude dimension')
latitudes[:] = latvals[:]
longitudes[:] = lonvals[:]
z_hybrid_heights[:] = zvals[:]
f2.close()
f.close()
def ConvertNCCF(TheFileIn,TheFileOut,TheTimes,TheDaysArray,TheCLats,TheCLongs,TheClimPeriod,TheMissing,TheType):
''' Discover what is in the file '''
''' Open and read in all bits '''
''' Write out in cf compliant style '''
ncf=Dataset(TheFileIn,'r')
nc_dims = list(ncf.dimensions) # list of dimensions [dim for dim in ncf.dimensions]
nc_vars = list(ncf.variables) # list of nc variables [var for var in ncf.variables]
nc_attrs = ncf.ncattrs() # list of global attributes
ndims=len(nc_dims)
nvars=len(nc_vars)
ngatts=len(nc_attrs)
# Get all global attributes
TheGAtts=np.empty(ngatts,dtype=object) # an empty array with the right number of string elements
for (noo,att) in enumerate(nc_attrs): # enumerate and use elements of the list
TheGAtts[noo]=ncf.getncattr(att) # get each global attribute and populate array
# Get all dimensions
TheDims=np.empty(ndims) # an empty array with the right number of string elements
for (noo,dim) in enumerate(nc_dims): # enumerate and use elements of the list
TheDims[noo]=len(ncf.dimensions[dim]) # get length of each dimension
# NO DIMENSION ATTRIBUTES -
# TheDimAttrNames=[[] for i in xrange(ndims)] # create list of lists - one for the attribute names of each dimension
# TheDimAttrs=[[] for i in xrange(ndims)] # create list of lists - one for the attributes of each dimension
# for (noo,dim) in enumerate(nc_dims): # enumerate and use elements of the list
# TheDimAttrNames[noo]=ncf.dimensions[dim].ncattrs() # fill names
# for (nee,nats) in enumerate(TheDimAttrNames[noo]): # loop through each name and get the attribute
# TheDimAttrs[noo][nee]=f.dimensions[dim].getncattr(nats)
# Get all variables, and their attributes
TheVarAttrNames=[[] for i in xrange(nvars)] # create list of lists - one for the attribute names of each dimension
TheVarAttrs=[[] for i in xrange(nvars)] # create list of lists - one for the attributes of each dimension
TheVars=[[] for i in xrange(nvars)] # create list of lists - one for the attributes of each dimension
for (noo,var) in enumerate(nc_vars): # enumerate and use elements of the list
TheVarAttrNames[noo]=ncf.variables[var].ncattrs() # fill names
for (nee,nats) in enumerate(TheVarAttrNames[noo]): # loop through each name and get the attribute
TheVarAttrs[noo].append(ncf.variables[var].getncattr(nats))
TheVars[noo]=ncf.variables[nc_vars[noo]][:]
# Now write out, checking if the standard stuff is not there, and if not, then add in
ncfw=Dataset(TheFileOut,'w',format='NETCDF3_CLASSIC')
# Set up the global attributes
# Is there a description?
moo=np.where(np.array(nc_attrs) == 'description')
if (moo[0] >= 0):
ncfw.description=TheGAtts[moo[0]]
else:
ncfw.description="HadISDH monthly mean land surface "+TheType+" climate monitoring product from 1973 onwards. Quality control, homogenisation, uncertainty estimation, averaging over gridboxes (no smoothing or interpolation)."
# Is there a title?
moo=np.where(np.array(nc_attrs) == 'title')
if (moo[0] >= 0):
ncfw.title=TheGAtts[moo[0]]
else:
ncfw.title="HadISDH monthly mean land surface "+TheType+" climate monitoring product from 1973 onwards."
# Is there an institution?
moo=np.where(np.array(nc_attrs) == 'institution')
if (moo[0] >= 0):
ncfw.institution=TheGAtts[moo[0]]
else:
ncfw.institution="Met Office Hadley Centre (UK), National Climatic Data Centre (USA), Climatic Research Unit (UK), National Physical Laboratory (UK), Bjerknes Centre for Climate Research (Norway)"
# Is there a history?
moo=np.where(np.array(nc_attrs) == 'history')
if (moo[0] >= 0):
ncfw.history=TheGAtts[moo[0]]
else:
ncfw.history="Updated 4 February 2014"
# Is there a source?
moo=np.where(np.array(nc_attrs) == 'source')
if (moo[0] >= 0):
ncfw.source=TheGAtts[moo[0]]
else:
ncfw.source="HadISD.1.0.2.2013f (Dunn et al., 2012)"
# Is there a comment?
moo=np.where(np.array(nc_attrs) == 'comment')
if (moo[0] >= 0):
ncfw.comment=TheGAtts[moo[0]]
else:
ncfw.comment=""
# Is there a reference?
moo=np.where(np.array(nc_attrs) == 'reference')
if (moo[0] >= 0):
ncfw.reference=TheGAtts[moo[0]]
else:
ncfw.reference="Willett, K. M., Dunn, R. J. H., Thorne, P. W., Bell, S., de Podesta, M., Parker, D. E., Jones, P. D., and Williams Jr., C. N.: HadISDH land surface multi-variable humidity and temperature record for climate monitoring, Clim. Past, 10, 1983-2006, doi:10.5194/cp-10-1983-2014, 2014."
# Is there a version?
moo=np.where(np.array(nc_attrs) == 'version')
if (moo[0] >= 0):
ncfw.version=TheGAtts[moo[0]]
else:
ncfw.version="HadISDH.2.0.0.2013p"
# Is there a Conventions?
moo=np.where(np.array(nc_attrs) == 'Conventions')
if (moo[0] >= 0):
ncfw.Conventions=TheGAtts[moo[0]]
else:
ncfw.Conventions="CF-1.0"
# Now set up the dimensions (time, latitude, longitude, optional-month)
data={} # Not really sure what this is about
moo=np.where(np.array(nc_dims) == 'time')
goo=np.where(np.array(nc_vars) == 'time')
if not(goo[0] >= 0): goo=np.where(np.array(nc_vars) == 'times') # Look for mistakes in HadISDH
if (moo[0] >= 0) & (goo[0] >= 0):
ncfw.createDimension(nc_dims[moo[0]],ncf.variables[nc_vars[goo[0]]].size)
else:
ncfw.createDimension('time',TheTimes)
data['time']=ncfw.createVariable('time','f8',('time',))
data['time'].setncattr('standard_name',u'time')
data['time'].setncattr('long_name',u'time')
data['time'].setncattr('units',u'days since 1973-1-1 00:00:00')
data['time'].setncattr('calendar',u'gregorian')
data['time'].setncattr('start_year',u'1973s')
data['time'].setncattr('end_year',u'2013s')
data['time'].setncattr('start_month',u'1s')
data['time'].setncattr('end_month',u'12s')
data['time'].setncattr('axis',u'T')
moo=np.where(np.array(nc_dims) == 'latitude')
goo=np.where(np.array(nc_vars) == 'latitude')
if not(goo[0] >= 0): goo=np.where(np.array(nc_vars) == 'lat') # Look for mistakes in HadISDH
if (moo[0] >= 0) & (goo[0] >= 0):
ncfw.createDimension(nc_dims[moo[0]],ncf.variables[nc_vars[goo[0]]].size)
else:
ncfw.createDimension('latitude',TheCLats)
data['latitude']=ncfw.createVariable('latitude','f8',('latitude',))
data['latitude'].setncattr('standard_name',u'latitude')
data['latitude'].setncattr('long_name',u'latitude')
data['latitude'].setncattr('units',u'degrees_north')
data['latitude'].setncattr('point_spacing',u'even')
data['latitude'].setncattr('axis',u'Y')
moo=np.where(np.array(nc_dims) == 'longitude')
goo=np.where(np.array(nc_vars) == 'longitude')
if not(goo[0] >= 0): goo=np.where(np.array(nc_vars) == 'lon') # Look for mistakes in HadISDH
if (moo[0] >= 0) & (goo[0] >= 0):
ncfw.createDimension(nc_dims[moo[0]],ncf.variables[nc_vars[goo[0]]].size)
else:
ncfw.createDimension('longitude',TheCLongs)
data['longitude']=ncfw.createVariable('longitude','f8',('longitude',))
data['longitude'].setncattr('standard_name',u'longitude')
data['longitude'].setncattr('long_name',u'longitude')
data['longitude'].setncattr('units',u'degrees_east')
data['longitude'].setncattr('point_spacing',u'even')
data['longitude'].setncattr('axis',u'X')
makemonth=0
moo=np.where(np.array(nc_dims) == 'month')
goo=np.where(np.array(nc_vars) == 'month')
if not(goo[0] >= 0): goo=np.where(np.array(nc_vars) == 'months') # Look for mistakes in HadISDH
if (moo[0] >= 0) & (goo[0] >= 0):
makemonth=1
ncfw.createDimension('month',12)
data['month']=ncfw.createVariable('month','i',('month',))
data['month'].setncattr('standard_name',u'month')
data['month'].setncattr('long_name',u'month')
data['month'].setncattr('units',u'days since 1973-1-1 00:00:00')
data['month'].setncattr('calendar',u'gregorian')
data['month'].setncattr('start_year',u'1973s')
data['month'].setncattr('end_year',u'1973s')
data['month'].setncattr('start_month',u'1s')
data['month'].setncattr('end_month',u'12s')
data['month'].setncattr('axis',u'T')
# Now set up the variables
# stop()
for loo in range(nvars): # miss out time, lat and lon - and month at the end
print(loo)
if (nc_vars[loo] != 'time') & (nc_vars[loo] != 'latitude') & (nc_vars[loo] != 'longitude') & (nc_vars[loo] != 'month') & \
(nc_vars[loo] != 'times') & (nc_vars[loo] != 'latitudes') & (nc_vars[loo] != 'longitudes') & (nc_vars[loo] != 'months') & \
(nc_vars[loo] != 'lat') & (nc_vars[loo] != 'lon'):
print(nc_vars[loo])
ncfw_var=ncfw.createVariable(nc_vars[loo],ncf.variables[nc_vars[loo]].dtype,ncf.variables[nc_vars[loo]].dimensions)
if (any(np.where(np.array(ncf.variables[nc_vars[loo]].ncattrs()) == '_FillValue'))):
ncfw_var.setncattr('_FillValue',ncf.variables[nc_vars[loo]].getncattr('_FillValue'))
elif (any(np.where(np.array(ncf.variables[nc_vars[loo]].ncattrs()) == 'missing_value'))):
ncfw_var.setncattr('_FillValue',ncf.variables[nc_vars[loo]].getncattr('missing_value'))
else:
ncfw_var.setncattr('_FillValue',TheMissing)
if (any(np.where(np.array(ncf.variables[nc_vars[loo]].ncattrs()) == 'missing_value'))):
ncfw_var.setncattr('missing_value',ncf.variables[nc_vars[loo]].getncattr('missing_value'))
elif (any(np.where(np.array(ncf.variables[nc_vars[loo]].ncattrs()) == '_FillValue'))):
ncfw_var.setncattr('missing_value',ncf.variables[nc_vars[loo]].getncattr('_FillValue'))
else:
ncfw_var.setncattr('missing_value',TheMissing)
if (any(np.where(np.array(ncf.variables[nc_vars[loo]].ncattrs()) == 'valid_min'))):
ncfw_var.setncattr('valid_min',ncf.variables[nc_vars[loo]].getncattr('valid_min'))
else:
ncfw_var.setncattr('valid_min',min(ncf.variables[nc_vars[0]][np.where(ncf.variables[nc_vars[0]][:] != TheMissing)]))
if (any(np.where(np.array(ncf.variables[nc_vars[loo]].ncattrs()) == 'valid_max'))):
ncfw_var.setncattr('valid_max',ncf.variables[nc_vars[loo]].getncattr('valid_max'))
else:
ncfw_var.setncattr('valid_max',max(ncf.variables[nc_vars[0]][np.where(ncf.variables[nc_vars[0]][:] != TheMissing)]))
if (any(np.where(np.array(ncf.variables[nc_vars[loo]].ncattrs()) == 'reference_period'))):
ncfw_var.setncattr('reference_period',ncf.variables[nc_vars[loo]].getncattr('reference_period'))
else:
ncfw_var.setncattr('reference_period',ClimPeriod)
ncfw_var.setncatts({'long_name':ncf.variables[nc_vars[loo]].getncattr('long_name'),
'units':ncf.variables[nc_vars[loo]].getncattr('units')})
# Now fill the variables
ncfw.variables['time'][:]=TheDaysArray
ncfw.variables['latitude'][:]=ncf.variables[nc_vars[1]][:]
ncfw.variables['longitude'][:]=ncf.variables[nc_vars[2]][:]
if (makemonth == 1):
ncfw.variables['month'][:]=TheDaysArray[0:12]
for loo in range((nvars)): # miss out time, lat and lon
print(loo)
if (nc_vars[loo] != 'time') & (nc_vars[loo] != 'latitude') & (nc_vars[loo] != 'longitude') & (nc_vars[loo] != 'month') & \
(nc_vars[loo] != 'times') & (nc_vars[loo] != 'latitudes') & (nc_vars[loo] != 'longitudes') & (nc_vars[loo] != 'months') & \
(nc_vars[loo] != 'lat') & (nc_vars[loo] != 'lon'):
print(nc_vars[loo])
ncfw.variables[nc_vars[loo]][:]=ncf.variables[nc_vars[loo]][:]
ncfw.close()
return # ConvertNCCF
def outputNC(output_file, ds, total, interest_lon, interest_lat, time_steps,
var_list, avg_dict):
print('Writing new nc4 file')
nc4_out = Dataset(output_file, 'w', format='NETCDF4')
time = nc4_out.createDimension("time", None)
lat = nc4_out.createDimension("lat", len(ds.lat.data))
lon = nc4_out.createDimension("lon", len(ds.lon.data))
# copying dimentions
time = nc4_out.createVariable("time", "i4", ("time", ))
days = []
for i in ds.time.data:
year = int(str(i).split('T')[0].split('-')[0])
month = int(str(i).split('T')[0].split('-')[1])
day = int(str(i).split('T')[0].split('-')[1])
dt = datetime.datetime(year, month, day) - datetime.datetime(
2002, 1, 1)
days.append(dt.days)
days = numpy.array(days)
time[:] = days
lat = nc4_out.createVariable("lat", "f4", ("lat", ))
lat[:] = ds.lat.data[:]
lon = nc4_out.createVariable("lon", "f4", ("lon", ))
lon[:] = ds.lon.data[:]
crs = nc4_out.createVariable("crs", "i4")
if 'time' in ds.variables:
var = ds['time']
if 'standard_name' in var.attrs:
time.standard_name = var.standard_name
if 'long_name' in var.attrs:
time.long_name = "time"
if 'units' not in var.attrs:
time.units = "days since 2002-01-01 00:00:00 UTC"
if 'axis' in var.attrs:
time.axis = var.axis
if 'calendar' not in var.attrs:
time.calendar = "gregorian"
if 'bounds' in var.attrs:
time.bounds = var.bounds
if 'lat' in ds.variables:
var = ds['lat']
if 'standard_name' in var.attrs:
lat.standard_name = var.standard_name
if 'long_name' in var.attrs:
lat.long_name = var.long_name
if 'units' in var.attrs:
lat.units = var.units
if 'axis' in var.attrs:
lat.axis = var.axis
if 'lon' in ds.variables:
var = ds['lon']
if 'standard_name' in var.attrs:
lon.standard_name = var.standard_name
if 'long_name' in var.attrs:
lon.long_name = var.long_name
if 'units' in var.attrs:
lon.units = var.units
if 'axis' in var.attrs:
lon.axis = var.axis
#copying variables
for (name, value) in ds.data_vars.items():
nc4_vars = nc4_out.createVariable(name, value.dtype, value.dims)
nc4_vars.setncatts(ds[name].attrs)
dt = datetime.datetime.utcnow()
dt = dt.replace(microsecond=0)
nc4_out.Conventions = 'CF-1.6'
nc4_out.title = ''
nc4_out.institution = ''
nc4_out.history = 'date created: ' + dt.isoformat() + '+00:00'
nc4_out.references = 'https://github.com/c-h-david/shbaam/'
nc4_out.comment = ''
nc4_out.featureType = 'timeSeries'
for var in var_list:
nc4_out[var][:, :, :] = numpy.nan
for i in range(total):
lon_index, lat_index = interest_lon[i][0], interest_lat[i][0]
long_term_mean = avg_dict[var][i]
for time in range(time_steps):
nc4_out[var][time, lat_index,
lon_index] = ds[var][time, lat_index,
lon_index] - long_term_mean
nc4_out.close()
print("Success -- creating nc4 file\n")
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # from pysofaconventions import * from netCDF4 import Dataset import time import numpy as np import soundfile as sf #----------Create it----------# filePath = "/Volumes/Dinge/SOFA/S3A/AudioBooth.sofa" rootgrp = Dataset(filePath, 'w', format='NETCDF4') #----------Required Attributes----------# rootgrp.Conventions = 'SOFA' rootgrp.Version = SOFAAPI.getAPIVersion() rootgrp.SOFAConventions = 'AmbisonicsDRIR' rootgrp.SOFAConventionsVersion = SOFAAmbisonicsDRIR.getConventionVersion() rootgrp.APIName = 'pysofaconventions' rootgrp.APIVersion = SOFAAPI.getAPIVersion() rootgrp.AuthorContact = '*****@*****.**' rootgrp.Organization = 'Eurecat - UPF' rootgrp.License = 'Please ask authors for permission' rootgrp.DataType = 'FIRE' rootgrp.RoomType = 'reverberant' rootgrp.DateCreated = time.ctime(time.time()) rootgrp.DateModified = time.ctime(time.time()) rootgrp.Title = 'AudioBooth' rootgrp.AmbisonicsOrder = '1'
def createBryFile(confM2R):
if (confM2R.myformat == 'NETCDF4'):
myzlib = True
else:
myzlib = False
grdROMS = confM2R.grdROMS
if os.path.exists(confM2R.bryname):
os.remove(confM2R.bryname)
print(('\n=>Creating initial Boundary (BRY) file {}'.format(confM2R.bryname)))
f1 = Dataset(confM2R.bryname, mode='w', format=confM2R.myformat)
f1.title = "Boundary forcing file (BRY) used for forcing of the ROMS model"
f1.description = "Created for the {} grid file".format(confM2R.romsgridpath)
f1.grdFile = "{}".format(confM2R.romsgridpath)
f1.history = 'Created ' + time.ctime(time.time())
f1.source = "{} ({})".format(confM2R.authorname, confM2R.authoremail)
f1.type = "File in {} format created using MODEL2ROMS".format(confM2R.myformat)
f1.link = "https://github.com/trondkr/model2roms"
f1.Conventions = "CF-1.0"
""" Define dimensions """
f1.createDimension('xi_rho', grdROMS.xi_rho)
f1.createDimension('eta_rho', grdROMS.eta_rho)
f1.createDimension('xi_u', grdROMS.xi_u)
f1.createDimension('eta_u', grdROMS.eta_u)
f1.createDimension('xi_v', grdROMS.xi_v)
f1.createDimension('eta_v', grdROMS.eta_v)
f1.createDimension('xi_psi', grdROMS.xi_psi)
f1.createDimension('eta_psi', grdROMS.eta_psi)
f1.createDimension('ocean_time', None)
f1.createDimension('s_rho', len(grdROMS.s_rho))
f1.createDimension('s_w', len(grdROMS.s_w))
vnc = f1.createVariable('lon_rho', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of RHO-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_rho
vnc = f1.createVariable('lat_rho', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of RHO-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_rho
vnc = f1.createVariable('lon_u', 'd', ('eta_u', 'xi_u',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of U-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_u
vnc = f1.createVariable('lat_u', 'd', ('eta_u', 'xi_u',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of U-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_u
vnc = f1.createVariable('lon_v', 'd', ('eta_v', 'xi_v',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of V-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_v
vnc = f1.createVariable('lat_v', 'd', ('eta_v', 'xi_v',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of V-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_v
vnc = f1.createVariable('lat_psi', 'd', ('eta_psi', 'xi_psi',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of PSI-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_psi
vnc = f1.createVariable('lon_psi', 'd', ('eta_psi', 'xi_psi',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of PSI-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_psi
vnc = f1.createVariable('h', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "Bathymetry at RHO-points"
vnc.units = "meter"
vnc.coordinates = "lat_rho lon_rho"
vnc.field = "bath, scalar"
vnc[:, :] = grdROMS.h
vnc = f1.createVariable('s_rho', 'd', ('s_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate at RHO-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
if grdROMS.vtransform == 2:
vnc.standard_name = "ocean_s_coordinate_g2"
vnc.formula_terms = "s: s_rho C: Cs_r eta: zeta depth: h depth_c: hc"
if grdROMS.vtransform == 1:
vnc.standard_name = "ocean_s_coordinate_g1"
vnc.formula_terms = "s: s_rho C: Cs_r eta: zeta depth: h depth_c: hc"
vnc.field = "s_rho, scalar"
vnc[:] = grdROMS.s_rho
vnc = f1.createVariable('s_w', 'd', ('s_w',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate at W-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
if grdROMS.vtransform == 2:
vnc.standard_name = "ocean_s_coordinate_g2"
vnc.formula_terms = "s: s_w C: Cs_w eta: zeta depth: h depth_c: hc"
if grdROMS.vtransform == 1:
vnc.standard_name = "ocean_s_coordinate_g1"
vnc.formula_terms = "s: s_w C: Cs_w eta: zeta depth: h depth_c: hc"
vnc.field = "s_w, scalar"
vnc[:] = grdROMS.s_w
vnc = f1.createVariable('Cs_r', 'd', ('s_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate stretching curves at RHO-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.field = "Cs_rho, scalar"
vnc[:] = grdROMS.Cs_rho
vnc = f1.createVariable('Cs_w', 'd', ('s_w',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate stretching curves at W-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.field = "Cs_w, scalar"
vnc[:] = grdROMS.Cs_w
vnc = f1.createVariable('hc', 'd')
vnc.long_name = "S-coordinate parameter, critical depth";
vnc.units = "meter"
vnc[:] = grdROMS.hc
vnc = f1.createVariable('z_r', 'd', ('s_rho', 'eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "Sigma layer to depth matrix";
vnc.units = "meter"
vnc[:, :, :] = grdROMS.z_r
vnc = f1.createVariable('Tcline', 'd')
vnc.long_name = "S-coordinate surface/bottom layer width"
vnc.units = "meter"
vnc[:] = grdROMS.tcline
vnc = f1.createVariable('theta_s', 'd')
vnc.long_name = "S-coordinate surface control parameter"
vnc[:] = grdROMS.theta_s
vnc = f1.createVariable('theta_b', 'd')
vnc.long_name = "S-coordinate bottom control parameter"
vnc[:] = grdROMS.theta_b
vnc = f1.createVariable('angle', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "angle between xi axis and east"
vnc.units = "radian"
v_time = f1.createVariable('ocean_time', 'd', ('ocean_time',), zlib=myzlib, fill_value=grdROMS.fillval)
v_time.long_name = 'seconds since 1948-01-01 00:00:00'
v_time.units = 'seconds since 1948-01-01 00:00:00'
v_time.field = 'time, scalar, series'
if (confM2R.oceanindatatype == "NORESM"):
v_time.calendar = 'noleap'
else:
v_time.calendar = 'standard'
v_temp_west = f1.createVariable('temp_west', 'f', ('ocean_time', 's_rho', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp_west.long_name = "potential temperature western boundary condition"
v_temp_west.units = "Celsius"
v_temp_west.field = "temp_west, scalar, series"
#v_temp_west.missing_value = grdROMS.fillval
v_temp_west.time = "ocean_time"
v_temp_east = f1.createVariable('temp_east', 'f', ('ocean_time', 's_rho', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp_east.long_name = "potential temperature eastern boundary condition"
v_temp_east.units = "Celsius"
v_temp_east.field = "temp_east, scalar, series"
#v_temp_east.missing_value = grdROMS.fillval
v_temp_east.time = "ocean_time"
v_temp_south = f1.createVariable('temp_south', 'f', ('ocean_time', 's_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp_south.long_name = "potential temperature southern boundary condition"
v_temp_south.units = "Celsius"
v_temp_south.field = "temp_south, scalar, series"
#v_temp_south.missing_value = grdROMS.fillval
v_temp_south.time = "ocean_time"
v_temp_north = f1.createVariable('temp_north', 'f', ('ocean_time', 's_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp_north.long_name = "potential temperature northern boundary condition"
v_temp_north.units = "Celsius"
v_temp_north.field = "temp_north, scalar, series"
#v_temp_north.missing_value = grdROMS.fillval
v_temp_north.time = "ocean_time"
v_salt_west = f1.createVariable('salt_west', 'f', ('ocean_time', 's_rho', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt_west.long_name = "salinity western boundary condition"
v_salt_west.field = "salt_west, scalar, series"
#v_salt_west.missing_value = grdROMS.fillval
v_salt_west.time = "ocean_time"
v_salt_east = f1.createVariable('salt_east', 'f', ('ocean_time', 's_rho', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt_east.long_name = "salinity eastern boundary condition"
v_salt_east.field = "salt_east, scalar, series"
#v_salt_east.missing_value = grdROMS.fillval
v_salt_east.time = "ocean_time"
v_salt_south = f1.createVariable('salt_south', 'f', ('ocean_time', 's_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt_south.long_name = "salinity southern boundary condition"
v_salt_south.field = "salt_south, scalar, series"
#v_salt_south.missing_value = grdROMS.fillval
v_salt_south.time = "ocean_time"
v_salt_north = f1.createVariable('salt_north', 'f', ('ocean_time', 's_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt_north.long_name = "salinity northern boundary condition"
v_salt_north.field = "salt_north, scalar, series"
#v_salt_north.missing_value = grdROMS.fillval
v_salt_north.time = "ocean_time"
v_ssh_west = f1.createVariable('zeta_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh_west.long_name = "free-surface western boundary condition"
v_ssh_west.units = "meter"
v_ssh_west.field = "zeta_west, scalar, series"
#v_ssh_west.missing_value = grdROMS.fillval
v_ssh_west.time = "ocean_time"
v_ssh_east = f1.createVariable('zeta_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh_east.long_name = "free-surface eastern boundary condition"
v_ssh_east.units = "meter"
v_ssh_east.field = "zeta_east, scalar, series"
#v_ssh_east.missing_value = grdROMS.fillval
v_ssh_east.time = "ocean_time"
v_ssh_south = f1.createVariable('zeta_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh_south.long_name = "free-surface southern boundary condition"
v_ssh_south.units = "meter"
v_ssh_south.field = "zeta_south, scalar, series"
#v_ssh_south.missing_value = grdROMS.fillval
v_ssh_south.time = "ocean_time"
v_ssh_north = f1.createVariable('zeta_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh_north.long_name = "free-surface northern boundary condition"
v_ssh_north.units = "meter"
v_ssh_north.field = "zeta_north, scalar, series"
#v_ssh_north.missing_value = grdROMS.fillval
v_ssh_north.time = "ocean_time"
v_u_west = f1.createVariable('u_west', 'f', ('ocean_time', 's_rho', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u_west.long_name = "3D u-momentum western boundary condition"
v_u_west.units = "meter second-1"
v_u_west.field = "u_west, scalar, series"
#v_u_west.missing_value = grdROMS.fillval
v_u_west.time = "ocean_time"
v_u_east = f1.createVariable('u_east', 'f', ('ocean_time', 's_rho', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u_east.long_name = "3D u-momentum eastern boundary condition"
v_u_east.units = "meter second-1"
v_u_east.field = "u_east, scalar, series"
#v_u_east.missing_value = grdROMS.fillval
v_u_east.time = "ocean_time"
v_u_south = f1.createVariable('u_south', 'f', ('ocean_time', 's_rho', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u_south.long_name = "3D u-momentum southern boundary condition"
v_u_south.units = "meter second-1"
v_u_south.field = "u_south, scalar, series"
#v_u_south.missing_value = grdROMS.fillval
v_u_south.time = "ocean_time"
v_u_north = f1.createVariable('u_north', 'f', ('ocean_time', 's_rho', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u_north.long_name = "3D u-momentum northern boundary condition"
v_u_north.units = "meter second-1"
v_u_north.field = "u_north, scalar, series"
#v_u_north.missing_value = grdROMS.fillval
v_u_north.time = "ocean_time"
v_v_west = f1.createVariable('v_west', 'f', ('ocean_time', 's_rho', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v_west.long_name = "3D v-momentum western boundary condition"
v_v_west.units = "meter second-1"
v_v_west.field = "v_west, scalar, series"
#v_v_west.missing_value = grdROMS.fillval
v_v_west.time = "ocean_time"
v_v_east = f1.createVariable('v_east', 'f', ('ocean_time', 's_rho', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v_east.long_name = "3D v-momentum eastern boundary condition"
v_v_east.units = "meter second-1"
v_v_east.field = "v_east, scalar, series"
#v_v_east.missing_value = grdROMS.fillval
v_v_east.time = "ocean_time"
v_v_south = f1.createVariable('v_south', 'f', ('ocean_time', 's_rho', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v_south.long_name = "3D v-momentum southern boundary condition"
v_v_south.units = "meter second-1"
v_v_south.field = "v_south, scalar, series"
#v_v_south.missing_value = grdROMS.fillval
v_v_south.time = "ocean_time"
v_v_north = f1.createVariable('v_north', 'f', ('ocean_time', 's_rho', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v_north.long_name = "3D v-momentum northern boundary condition"
v_v_north.units = "meter second-1"
v_v_north.field = "v_north, scalar, series"
#v_v_north.missing_value = grdROMS.fillval
v_v_north.time = "ocean_time"
v_vbar_west = f1.createVariable('vbar_west', 'f', ('ocean_time', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar_west.long_name = "2D v-momentum western boundary condition"
v_vbar_west.units = "meter second-1"
v_vbar_west.field = "vbar_west, scalar, series"
#v_vbar_west.missing_value = grdROMS.fillval
v_vbar_west.time = "ocean_time"
v_vbar_east = f1.createVariable('vbar_east', 'f', ('ocean_time', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar_east.long_name = "2D v-momentum eastern boundary condition"
v_vbar_east.units = "meter second-1"
v_vbar_east.field = "vbar_east, scalar, series"
#v_vbar_east.missing_value = grdROMS.fillval
v_vbar_east.time = "ocean_time"
v_vbar_south = f1.createVariable('vbar_south', 'f', ('ocean_time', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar_south.long_name = "2D v-momentum southern boundary condition"
v_vbar_south.units = "meter second-1"
v_vbar_south.field = "vbar_south, scalar, series"
#v_vbar_south.missing_value = grdROMS.fillval
v_vbar_south.time = "ocean_time"
v_vbar_north = f1.createVariable('vbar_north', 'f', ('ocean_time', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar_north.long_name = "2D v-momentum northern boundary condition"
v_vbar_north.units = "meter second-1"
v_vbar_north.field = "vbar_north, scalar, series"
#v_vbar_north.missing_value = grdROMS.fillval
v_vbar_north.time = "ocean_time"
v_ubar_west = f1.createVariable('ubar_west', 'f', ('ocean_time', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar_west.long_name = "2D u-momentum western boundary condition"
v_ubar_west.units = "meter second-1"
v_ubar_west.field = "ubar_west, scalar, series"
# v_ubar_west.missing_value = grdROMS.fillval
v_ubar_west.time = "ocean_time"
v_ubar_east = f1.createVariable('ubar_east', 'f', ('ocean_time', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar_east.long_name = "2D u-momentum eastern boundary condition"
v_ubar_east.units = "meter second-1"
v_ubar_east.field = "ubar_east, scalar, series"
#v_ubar_east.missing_value = grdROMS.fillval
v_ubar_east.time = "ocean_time"
v_ubar_south = f1.createVariable('ubar_south', 'f', ('ocean_time', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar_south.long_name = "2D u-momentum southern boundary condition"
v_ubar_south.units = "meter second-1"
v_ubar_south.field = "ubar_south, scalar, series"
#v_ubar_south.missing_value = grdROMS.fillval
v_ubar_south.time = "ocean_time"
v_ubar_north = f1.createVariable('ubar_north', 'f', ('ocean_time', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar_north.long_name = "2D u-momentum northern boundary condition"
v_ubar_north.units = "meter second-1"
v_ubar_north.field = "ubar_north, scalar, series"
#v_ubar_north.missing_value = grdROMS.fillval
v_ubar_north.time = "ocean_time"
if confM2R.writebcg:
directions=['east','west','north','south']
dimens=['eta_rho','eta_rho','xi_rho','xi_rho']
lndirections=['eastern','western','northern','southern']
for currentdir,lndirection,dim in zip(directions, lndirections,dimens):
currentvar='O3_c_'+currentdir
longname="carbonate/total dissolved inorganic carbon {} boundary condition".format(lndirection)
O3_c = f1.createVariable(currentvar, 'f', ('ocean_time', 's_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
O3_c.long_name = longname
O3_c.field = "{}, scalar, series".format(currentvar)
O3_c.units = "mmol C/m^3"
currentvar='O3_TA_'+currentdir
longname="carbonate/bioalkalinity {} boundary condition".format(lndirection)
O3_ta = f1.createVariable(currentvar, 'f', ('ocean_time', 's_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
O3_ta.long_name = longname
O3_ta.field = "{}, scalar, series".format(currentvar)
O3_ta.units = "umol/kg"
currentvar='N1_p_'+currentdir
longname="phosphate/phosphorus {} boundary condition".format(lndirection)
N1_p = f1.createVariable(currentvar, 'f', ('ocean_time','s_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
N1_p.long_name = longname
N1_p.field = "{}, scalar, series".format(currentvar)
N1_p.units = "mmol P/m^3"
currentvar='N3_n_'+currentdir
longname="nitrate/nitrogen {} boundary condition".format(lndirection)
N3_n = f1.createVariable(currentvar, 'f', ('ocean_time','s_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
N3_n.long_name = longname
N3_n.field = "{}, scalar, series".format(currentvar)
N3_n.units = "mmol N/m^3"
currentvar='N5_s_'+currentdir
longname="silicate/silicate {} boundary condition".format(lndirection)
N5_s = f1.createVariable(currentvar, 'f', ('ocean_time','s_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
N5_s.long_name = longname
N5_s.field = "{}, scalar, series".format(currentvar)
N5_s.units = "mmol Si/m^3"
currentvar='O2_o_'+currentdir
longname="oxygen/oxygen {} boundary condition".format(lndirection)
O2_o = f1.createVariable(currentvar, 'f', ('ocean_time', 's_rho',dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
O2_o.long_name = longname
O2_o.field = "{}, scalar, series".format(currentvar)
O2_o.units = "mmol O_2/m^3"
if confM2R.writeice:
ageice_west = f1.createVariable('ageice_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice_west.long_name = "time-averaged age of the ice western boundary conditions"
ageice_west.units = "years"
ageice_west.time = "ocean_time"
ageice_west.field = "ice age, scalar, series"
#ageice_west.missing_value = grdROMS.fillval
ageice_east = f1.createVariable('ageice_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice_east.long_name = "time-averaged age of the ice eastern boundary conditions"
ageice_east.units = "years"
ageice_east.time = "ocean_time"
ageice_east.field = "ice age, scalar, series"
#ageice_east.missing_value = grdROMS.fillval
ageice_south = f1.createVariable('ageice_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice_south.long_name = "time-averaged age of the ice southern boundary conditions"
ageice_south.units = "years"
ageice_south.time = "ocean_time"
ageice_south.field = "ice age, scalar, series"
#ageice_south.missing_value = grdROMS.fillval
ageice_north = f1.createVariable('ageice_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice_north.long_name = "time-averaged age of the ice northern boundary conditions"
ageice_north.units = "years"
ageice_north.time = "ocean_time"
ageice_north.field = "ice age, scalar, series"
#ageice_north.missing_value = grdROMS.fillval
# ----------------------------------------
uice_west = f1.createVariable('uice_west', 'f', ('ocean_time', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice_west.long_name = "time-averaged age of the u-component of ice velocity western boundary conditions"
uice_west.units = "meter second-1"
uice_west.time = "ocean_time"
uice_west.field = "u-component of ice velocity, scalar, series"
#uice_west.missing_value = grdROMS.fillval
uice_east = f1.createVariable('uice_east', 'f', ('ocean_time', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice_east.long_name = "time-averaged age of the u-component of ice velocity eastern boundary conditions"
uice_east.units = "meter second-1"
uice_east.time = "ocean_time"
uice_east.field = "u-component of ice velocity, scalar, series"
#uice_east.missing_value = grdROMS.fillval
uice_south = f1.createVariable('uice_south', 'f', ('ocean_time', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice_south.long_name = "time-averaged age of the u-component of ice velocity southern boundary conditions"
uice_south.units = "meter second-1"
uice_south.time = "ocean_time"
uice_south.field = "u-component of ice velocity, scalar, series"
#uice_south.missing_value = grdROMS.fillval
uice_north = f1.createVariable('uice_north', 'f', ('ocean_time', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice_north.long_name = "time-averaged age of the u-component of ice velocity northern boundary conditions"
uice_north.units = "meter second-1"
uice_north.time = "ocean_time"
uice_north.field = "u-component of ice velocity, scalar, series"
#uice_north.missing_value = grdROMS.fillval
# ----------------------------------------
vice_west = f1.createVariable('vice_west', 'f', ('ocean_time', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice_west.long_name = "time-averaged age of the v-component of ice velocity western boundary conditions"
vice_west.units = "meter second-1"
uice_west.time = "ocean_time"
vice_west.field = "v-component of ice velocity, scalar, series"
#vice_west.missing_value = grdROMS.fillval
vice_east = f1.createVariable('vice_east', 'f', ('ocean_time', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice_east.long_name = "time-averaged age of the v-component of ice velocity eastern boundary conditions"
vice_east.units = "meter second-1"
vice_east.time = "ocean_time"
vice_east.field = "v-component of ice velocity, scalar, series"
#vice_east.missing_value = grdROMS.fillval
vice_south = f1.createVariable('vice_south', 'f', ('ocean_time', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice_south.long_name = "time-averaged age of the v-component of ice velocity southern boundary conditions"
vice_south.units = "meter second-1"
vice_south.time = "ocean_time"
vice_south.field = "v-component of ice velocity, scalar, series"
#vice_south.missing_value = grdROMS.fillval
vice_north = f1.createVariable('vice_north', 'f', ('ocean_time', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice_north.long_name = "time-averaged age of the u-component of ice velocity northern boundary conditions"
vice_north.units = "meter second-1"
vice_north.time = "ocean_time"
vice_north.field = "v-component of ice velocity, scalar, series"
#vice_north.missing_value = grdROMS.fillval
# ----------------------------------------
aice_west = f1.createVariable('aice_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice_west.long_name = "time-averaged fraction of cell covered by ice western boundary conditions"
aice_west.units = "%"
aice_west.time = "ocean_time"
aice_west.field = "ice concentration, scalar, series"
#aice_west.missing_value = grdROMS.fillval
aice_east = f1.createVariable('aice_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice_east.long_name = "time-averaged fraction of cell covered by ice eastern boundary conditions"
aice_east.units = "%"
aice_east.time = "ocean_time"
aice_east.field = "ice concentration, scalar, series"
#aice_east.missing_value = grdROMS.fillval
aice_south = f1.createVariable('aice_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice_south.long_name = "time-averaged fraction of cell covered by ice southern boundary conditions"
aice_south.units = "%"
aice_south.time = "ocean_time"
aice_south.field = "ice concentration, scalar, series"
#aice_south.missing_value = grdROMS.fillval
aice_north = f1.createVariable('aice_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice_north.long_name = "time-averaged fraction of cell covered by ice northern boundary conditions"
aice_north.units = "%"
aice_north.time = "ocean_time"
aice_north.field = "ice concentration, scalar, series"
#aice_north.missing_value = grdROMS.fillval
# ----------------------------------------
hice_west = f1.createVariable('hice_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice_west.long_name = "time-averaged ice thickness in cell western boundary conditions"
hice_west.units = "meter"
hice_west.time = "ocean_time"
hice_west.field = "ice thickness, scalar, series"
#hice_west.missing_value = grdROMS.fillval
hice_east = f1.createVariable('hice_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice_east.long_name = "time-averaged ice thickness in cell eastern boundary conditions"
hice_east.units = "meter"
hice_east.time = "ocean_time"
hice_east.field = "ice thickness, scalar, series"
#hice_east.missing_value = grdROMS.fillval
hice_south = f1.createVariable('hice_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice_south.long_name = "time-averaged ice thickness in cell southern boundary conditions"
hice_south.units = "meter"
hice_south.time = "ocean_time"
hice_south.field = "ice thickness, scalar, series"
#hice_south.missing_value = grdROMS.fillval
hice_north = f1.createVariable('hice_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice_north.long_name = "time-averaged ice thickness in cell northern boundary conditions"
hice_north.units = "meter"
hice_north.time = "ocean_time"
hice_north.field = "ice thickness, scalar, series"
#hice_north.missing_value = grdROMS.fillval
# ----------------------------------------
snow_thick_west = f1.createVariable('snow_thick_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick_west.long_name = "time-averaged ice thickness in cell western boundary conditions"
snow_thick_west.units = "meter"
snow_thick_west.time = "ocean_time"
snow_thick_west.field = "snow thickness, scalar, series"
#snow_thick_west.missing_value = grdROMS.fillval
snow_thick_east = f1.createVariable('snow_thick_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick_east.long_name = "time-averaged ice thickness in cell eastern boundary conditions"
snow_thick_east.units = "meter"
snow_thick_east.time = "ocean_time"
snow_thick_east.field = "snow thickness, scalar, series"
#snow_thick_east.missing_value = grdROMS.fillval
snow_thick_south = f1.createVariable('snow_thick_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick_south.long_name = "time-averaged ice thickness in cell southern boundary conditions"
snow_thick_south.units = "meter"
snow_thick_south.time = "ocean_time"
snow_thick_south.field = "snow thickness, scalar, series"
#snow_thick_south.missing_value = grdROMS.fillval
snow_thick_north = f1.createVariable('snow_thick_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick_north.long_name = "time-averaged ice thickness in cell northern boundary conditions"
snow_thick_north.units = "meter"
snow_thick_north.time = "ocean_time"
snow_thick_north.field = "snow thickness, scalar, series"
#snow_thick_north.missing_value = grdROMS.fillval
# ----------------------------------------
ti_west = f1.createVariable('ti_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti_west.long_name = "time-averaged interior ice temperature cell western boundary conditions"
ti_west.units = "degrees Celcius"
ti_west.time = "ocean_time"
ti_west.field = "interior temperature, scalar, series"
#ti_west.missing_value = grdROMS.fillval
ti_east = f1.createVariable('ti_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti_east.long_name = "time-averaged interior ice temperature eastern boundary conditions"
ti_east.units = "degrees Celcius"
ti_east.time = "ocean_time"
ti_east.field = "interior temperature, scalar, series"
#ti_east.missing_value = grdROMS.fillval
ti_south = f1.createVariable('ti_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti_south.long_name = "time-averaged interior ice temperature southern boundary conditions"
ti_south.units = "degrees Celcius"
ti_south.time = "ocean_time"
ti_south.field = "interior temperature, scalar, series"
#ti_south.missing_value = grdROMS.fillval
ti_north = f1.createVariable('ti_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti_north.long_name = "time-averaged interior ice temperature northern boundary conditions"
ti_north.units = "degrees Celcius"
ti_north.time = "ocean_time"
ti_north.field = "interior temperature, scalar, series"
#ti_north.missing_value = grdROMS.fillval
# ----------------------------------------
sfwat_west = f1.createVariable('sfwat_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat_west.long_name = "time-averaged surface melt water thickness on ice western boundary conditions"
sfwat_west.units = "meter"
sfwat_west.time = "ocean_time"
sfwat_west.field = "melt water thickness, scalar, series"
#sfwat_west.missing_value = grdROMS.fillval
sfwat_east = f1.createVariable('sfwat_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat_east.long_name = "time-averaged surface melt water thickness on ice eastern boundary conditions"
sfwat_east.units = "meter"
sfwat_east.time = "ocean_time"
sfwat_east.field = "melt water thickness, scalar, series"
#sfwat_east.missing_value = grdROMS.fillval
sfwat_south = f1.createVariable('sfwat_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat_south.long_name = "time-averaged surface melt water thickness on ice southern boundary conditions"
sfwat_south.units = "meter"
sfwat_south.time = "ocean_time"
sfwat_south.field = "melt water thickness, scalar, series"
#sfwat_south.missing_value = grdROMS.fillval
sfwat_north = f1.createVariable('sfwat_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat_north.long_name = "time-averaged surface melt water thickness on ice northern boundary conditions"
sfwat_north.units = "meter"
sfwat_north.time = "ocean_time"
sfwat_north.field = "melt water thickness, scalar, series"
#sfwat_north.missing_value = grdROMS.fillval
# ----------------------------------------
tisrf_west = f1.createVariable('tisrf_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf_west.long_name = "time-averaged temperature of ice surfacewestern boundary conditions"
tisrf_west.units = "degrees Celcius"
tisrf_west.time = "ocean_time"
tisrf_west.field = "surface temperature, scalar, series"
#tisrf_west.missing_value = grdROMS.fillval
tisrf_east = f1.createVariable('tisrf_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf_east.long_name = "time-averaged temperature of ice surface eastern boundary conditions"
tisrf_east.units = "degrees Celcius"
tisrf_east.time = "ocean_time"
tisrf_east.field = "surface temperature, scalar, series"
#tisrf_east.missing_value = grdROMS.fillval
tisrf_south = f1.createVariable('tisrf_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf_south.long_name = "time-averaged temperature of ice surface southern boundary conditions"
tisrf_south.units = "degrees Celcius"
tisrf_south.time = "ocean_time"
tisrf_south.field = "surface temperature, scalar, series"
#tisrf_south.missing_value = grdROMS.fillval
tisrf_north = f1.createVariable('tisrf_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf_north.long_name = "time-averaged temperature of ice surface northern boundary conditions"
tisrf_north.units = "degrees Celcius"
tisrf_north.time = "ocean_time"
tisrf_north.field = "surface temperature, scalar, series"
#tisrf_north.missing_value = grdROMS.fillval
# ----------------------------------------
sig11_west = f1.createVariable('sig11_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11_west.long_name = "time-averaged internal ice stress 11 component boundary conditions"
sig11_west.units = "Newton meter-1"
sig11_west.time = "ocean_time"
sig11_west.field = "ice stress 11, scalar, series"
#sig11_west.missing_value = grdROMS.fillval
sig11_east = f1.createVariable('sig11_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11_east.long_name = "time-averaged internal ice stress 11 component eastern boundary conditions"
sig11_east.units = "Newton meter-1"
sig11_east.time = "ocean_time"
sig11_east.field = "ice stress 11, scalar, series"
#sig11_east.missing_value = grdROMS.fillval
sig11_south = f1.createVariable('sig11_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11_south.long_name = "time-averaged internal ice stress 11 componentsouthern boundary conditions"
sig11_south.units = "Newton meter-1"
sig11_south.time = "ocean_time"
sig11_south.field = "ice stress 11, scalar, series"
#sig11_south.missing_value = grdROMS.fillval
sig11_north = f1.createVariable('sig11_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11_north.long_name = "time-averaged internal ice stress 11 component northern boundary conditions"
sig11_north.units = "Newton meter-1"
sig11_north.time = "ocean_time"
sig11_north.field = "ice stress 11, scalar, series"
#sig11_north.missing_value = grdROMS.fillval
# ----------------------------------------
sig12_west = f1.createVariable('sig12_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12_west.long_name = "time-averaged internal ice stress 12 component boundary conditions"
sig12_west.units = "Newton meter-1"
sig12_west.time = "ocean_time"
sig12_west.field = "ice stress 12, scalar, series"
#sig12_west.missing_value = grdROMS.fillval
sig12_east = f1.createVariable('sig12_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12_east.long_name = "time-averaged internal ice stress 12 component eastern boundary conditions"
sig12_east.units = "Newton meter-1"
sig12_east.time = "ocean_time"
sig12_east.field = "ice stress 12, scalar, series"
#sig12_east.missing_value = grdROMS.fillval
sig12_south = f1.createVariable('sig12_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12_south.long_name = "time-averaged internal ice stress 12 componentsouthern boundary conditions"
sig12_south.units = "Newton meter-1"
sig12_south.time = "ocean_time"
sig12_south.field = "ice stress 12, scalar, series"
#sig12_south.missing_value = grdROMS.fillval
sig12_north = f1.createVariable('sig12_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12_north.long_name = "time-averaged internal ice stress 12 component northern boundary conditions"
sig12_north.units = "Newton meter-1"
sig12_north.time = "ocean_time"
sig12_north.field = "ice stress 12, scalar, series"
#sig12_north.missing_value = grdROMS.fillval
# ----------------------------------------
sig22_west = f1.createVariable('sig22_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22_west.long_name = "time-averaged internal ice stress 22 component boundary conditions"
sig22_west.units = "Newton meter-1"
sig22_west.time = "ocean_time"
sig22_west.field = "ice stress 22, scalar, series"
#sig22_west.missing_value = grdROMS.fillval
sig22_east = f1.createVariable('sig22_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22_east.long_name = "time-averaged internal ice stress 22 component eastern boundary conditions"
sig22_east.units = "Newton meter-1"
sig22_east.time = "ocean_time"
sig22_east.field = "ice stress 22, scalar, series"
#sig22_east.missing_value = grdROMS.fillval
sig22_south = f1.createVariable('sig22_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22_south.long_name = "time-averaged internal ice stress 22 componentsouthern boundary conditions"
sig22_south.units = "Newton meter-1"
sig22_south.time = "ocean_time"
sig22_south.field = "ice stress 22, scalar, series"
#sig22_south.missing_value = grdROMS.fillval
sig22_north = f1.createVariable('sig22_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22_north.long_name = "time-averaged internal ice stress 22 component northern boundary conditions"
sig22_north.units = "Newton meter-1"
sig22_north.time = "ocean_time"
sig22_north.field = "ice stress 22, scalar, series"
#sig22_north.missing_value = grdROMS.fillval
# ----------------------------------------
f1.close()
def test_isValid():
fd, path = tempfile.mkstemp()
def raiseWarning(warningString):
generalTF = SOFAGeneralTF(path, 'r')
with pytest.warns(SOFAWarning) as record:
assert not generalTF.isValid()
assert warningString in str(record[-1].message)
generalTF.close()
## Validity of SOFAFile
# File not valid
rootgrp = Dataset(path, 'w', format='NETCDF4')
rootgrp.close()
raiseWarning('Missing required attribute: APIName')
os.remove(path)
# SOFA File valid
rootgrp = Dataset(path, 'w', format='NETCDF4')
# Attributes
rootgrp.Conventions = 'SOFA'
rootgrp.Version = '1.0'
rootgrp.SOFAConventions = 'GeneralFIRE'
rootgrp.SOFAConventionsVersion = '0.1'
rootgrp.APIName = 'pysofaconventions'
rootgrp.APIVersion = '0.1'
rootgrp.APIVersion = '0.1'
rootgrp.AuthorContact = '*****@*****.**'
rootgrp.Organization = 'Eurecat - UPF'
rootgrp.License = 'WTFPL - Do What the F**k You Want to Public License'
rootgrp.DataType = 'FIRE'
rootgrp.RoomType = 'reverberant'
rootgrp.DateCreated = time.ctime(time.time())
rootgrp.DateModified = time.ctime(time.time())
rootgrp.Title = 'testpysofaconventions'
# Dimensions
rootgrp.createDimension('I', 1)
rootgrp.createDimension('N', 2)
rootgrp.createDimension('C', 3)
rootgrp.createDimension('M', 4)
rootgrp.createDimension('R', 5)
rootgrp.createDimension('E', 6)
# Variables
sr = rootgrp.createVariable('Data.SamplingRate', 'f8', ('I', ))
sr.Units = 'hertz'
rootgrp.createVariable('Data.Delay', 'f8', ('M', 'R', 'E'))
rootgrp.createVariable('Data.IR', 'f8', ('M', 'R', 'E', 'N'))
listenerPositionVar = rootgrp.createVariable('ListenerPosition', 'f8',
('I', 'C'))
listenerPositionVar.Units = 'metre'
listenerPositionVar.Type = 'cartesian'
sourcePositionVar = rootgrp.createVariable('SourcePosition', 'f8',
('I', 'C'))
sourcePositionVar.Units = 'metre'
sourcePositionVar.Type = 'cartesian'
receiverPositionVar = rootgrp.createVariable('ReceiverPosition', 'f8',
('R', 'C', 'I'))
receiverPositionVar.Units = 'metre'
receiverPositionVar.Type = 'cartesian'
emitterPositionVar = rootgrp.createVariable('EmitterPosition', 'f8',
('E', 'C', 'M'))
emitterPositionVar.Units = 'metre'
emitterPositionVar.Type = 'cartesian'
rootgrp.close()
## Specific validity
# Data type should be FIR
raiseWarning('DataType is not "TF", got: "FIRE"')
# Adjust data type and required variables to change
rootgrp = Dataset(path, 'a')
rootgrp.DataType = 'TF'
rootgrp.createVariable('Data.Real', 'f8', ('M', 'R', 'N'))
rootgrp.createVariable('Data.Imag', 'f8', ('M', 'R', 'N'))
n = rootgrp.createVariable('N', 'f8', ('N', ))
n.Units = 'hertz'
rootgrp.close()
# SOFAConventions should be GeneralTF
raiseWarning('SOFAConventions is not "GeneralTF", got: "GeneralFIRE"')
rootgrp = Dataset(path, 'a')
rootgrp.SOFAConventions = 'GeneralTF'
rootgrp.close()
# All right
generalTF = SOFAGeneralTF(path, 'r')
assert generalTF.isValid()
generalTF.close()
os.remove(path)
def createBryFile(confM2R):
if (confM2R.myformat == 'NETCDF4'):
myzlib = True
else:
myzlib = False
grdROMS = confM2R.grdROMS
if os.path.exists(confM2R.bryname):
os.remove(confM2R.bryname)
print(('\n=>Creating initial Boundary (BRY) file {}'.format(confM2R.bryname)))
f1 = Dataset(confM2R.bryname, mode='w', format=confM2R.myformat)
f1.title = "Boundary forcing file (BRY) used for forcing of the ROMS model"
f1.description = "Created for the {} grid file".format(confM2R.romsgridpath)
f1.grdFile = "{}".format(confM2R.romsgridpath)
f1.history = 'Created ' + time.ctime(time.time())
f1.source = "{} ({})".format(confM2R.authorname, confM2R.authoremail)
f1.type = "File in {} format created using MODEL2ROMS".format(confM2R.myformat)
f1.link = "https://github.com/trondkr/model2roms"
f1.Conventions = "CF-1.0"
""" Define dimensions """
f1.createDimension('xi_rho', grdROMS.xi_rho)
f1.createDimension('eta_rho', grdROMS.eta_rho)
f1.createDimension('xi_u', grdROMS.xi_u)
f1.createDimension('eta_u', grdROMS.eta_u)
f1.createDimension('xi_v', grdROMS.xi_v)
f1.createDimension('eta_v', grdROMS.eta_v)
f1.createDimension('xi_psi', grdROMS.xi_psi)
f1.createDimension('eta_psi', grdROMS.eta_psi)
f1.createDimension('ocean_time', None)
f1.createDimension('s_rho', len(grdROMS.s_rho))
f1.createDimension('s_w', len(grdROMS.s_w))
vnc = f1.createVariable('lon_rho', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of RHO-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_rho
vnc = f1.createVariable('lat_rho', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of RHO-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_rho
vnc = f1.createVariable('lon_u', 'd', ('eta_u', 'xi_u',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of U-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_u
vnc = f1.createVariable('lat_u', 'd', ('eta_u', 'xi_u',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of U-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_u
vnc = f1.createVariable('lon_v', 'd', ('eta_v', 'xi_v',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of V-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_v
vnc = f1.createVariable('lat_v', 'd', ('eta_v', 'xi_v',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of V-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_v
vnc = f1.createVariable('lat_psi', 'd', ('eta_psi', 'xi_psi',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of PSI-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_psi
vnc = f1.createVariable('lon_psi', 'd', ('eta_psi', 'xi_psi',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of PSI-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_psi
vnc = f1.createVariable('h', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "Bathymetry at RHO-points"
vnc.units = "meter"
vnc.coordinates = "lat_rho lon_rho"
vnc.field = "bath, scalar"
vnc[:, :] = grdROMS.h
vnc = f1.createVariable('s_rho', 'd', ('s_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate at RHO-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
if grdROMS.vtransform == 2:
vnc.standard_name = "ocean_s_coordinate_g2"
vnc.formula_terms = "s: s_rho C: Cs_r eta: zeta depth: h depth_c: hc"
if grdROMS.vtransform == 1:
vnc.standard_name = "ocean_s_coordinate_g1"
vnc.formula_terms = "s: s_rho C: Cs_r eta: zeta depth: h depth_c: hc"
vnc.field = "s_rho, scalar"
vnc[:] = grdROMS.s_rho
vnc = f1.createVariable('s_w', 'd', ('s_w',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate at W-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
if grdROMS.vtransform == 2:
vnc.standard_name = "ocean_s_coordinate_g2"
vnc.formula_terms = "s: s_w C: Cs_w eta: zeta depth: h depth_c: hc"
if grdROMS.vtransform == 1:
vnc.standard_name = "ocean_s_coordinate_g1"
vnc.formula_terms = "s: s_w C: Cs_w eta: zeta depth: h depth_c: hc"
vnc.field = "s_w, scalar"
vnc[:] = grdROMS.s_w
vnc = f1.createVariable('Cs_r', 'd', ('s_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate stretching curves at RHO-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.field = "Cs_rho, scalar"
vnc[:] = grdROMS.Cs_rho
vnc = f1.createVariable('Cs_w', 'd', ('s_w',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate stretching curves at W-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.field = "Cs_w, scalar"
vnc[:] = grdROMS.Cs_w
vnc = f1.createVariable('hc', 'd')
vnc.long_name = "S-coordinate parameter, critical depth";
vnc.units = "meter"
vnc[:] = grdROMS.hc
vnc = f1.createVariable('z_r', 'd', ('s_rho', 'eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "Sigma layer to depth matrix";
vnc.units = "meter"
vnc[:, :, :] = grdROMS.z_r
vnc = f1.createVariable('Tcline', 'd')
vnc.long_name = "S-coordinate surface/bottom layer width"
vnc.units = "meter"
vnc[:] = grdROMS.tcline
vnc = f1.createVariable('theta_s', 'd')
vnc.long_name = "S-coordinate surface control parameter"
vnc[:] = grdROMS.theta_s
vnc = f1.createVariable('theta_b', 'd')
vnc.long_name = "S-coordinate bottom control parameter"
vnc[:] = grdROMS.theta_b
vnc = f1.createVariable('angle', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "angle between xi axis and east"
vnc.units = "radian"
v_time = f1.createVariable('ocean_time', 'd', ('ocean_time',), zlib=myzlib, fill_value=grdROMS.fillval)
v_time.long_name = 'seconds since 1948-01-01 00:00:00'
v_time.units = 'seconds since 1948-01-01 00:00:00'
v_time.field = 'time, scalar, series'
if (confM2R.indatatype == "NORESM"):
v_time.calendar = 'noleap'
else:
v_time.calendar = 'standard'
v_temp_west = f1.createVariable('temp_west', 'f', ('ocean_time', 's_rho', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp_west.long_name = "potential temperature western boundary condition"
v_temp_west.units = "Celsius"
v_temp_west.field = "temp_west, scalar, series"
#v_temp_west.missing_value = grdROMS.fillval
v_temp_west.time = "ocean_time"
v_temp_east = f1.createVariable('temp_east', 'f', ('ocean_time', 's_rho', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp_east.long_name = "potential temperature eastern boundary condition"
v_temp_east.units = "Celsius"
v_temp_east.field = "temp_east, scalar, series"
#v_temp_east.missing_value = grdROMS.fillval
v_temp_east.time = "ocean_time"
v_temp_south = f1.createVariable('temp_south', 'f', ('ocean_time', 's_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp_south.long_name = "potential temperature southern boundary condition"
v_temp_south.units = "Celsius"
v_temp_south.field = "temp_south, scalar, series"
#v_temp_south.missing_value = grdROMS.fillval
v_temp_south.time = "ocean_time"
v_temp_north = f1.createVariable('temp_north', 'f', ('ocean_time', 's_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp_north.long_name = "potential temperature northern boundary condition"
v_temp_north.units = "Celsius"
v_temp_north.field = "temp_north, scalar, series"
#v_temp_north.missing_value = grdROMS.fillval
v_temp_north.time = "ocean_time"
v_salt_west = f1.createVariable('salt_west', 'f', ('ocean_time', 's_rho', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt_west.long_name = "salinity western boundary condition"
v_salt_west.field = "salt_west, scalar, series"
#v_salt_west.missing_value = grdROMS.fillval
v_salt_west.time = "ocean_time"
v_salt_east = f1.createVariable('salt_east', 'f', ('ocean_time', 's_rho', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt_east.long_name = "salinity eastern boundary condition"
v_salt_east.field = "salt_east, scalar, series"
#v_salt_east.missing_value = grdROMS.fillval
v_salt_east.time = "ocean_time"
v_salt_south = f1.createVariable('salt_south', 'f', ('ocean_time', 's_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt_south.long_name = "salinity southern boundary condition"
v_salt_south.field = "salt_south, scalar, series"
#v_salt_south.missing_value = grdROMS.fillval
v_salt_south.time = "ocean_time"
v_salt_north = f1.createVariable('salt_north', 'f', ('ocean_time', 's_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt_north.long_name = "salinity northern boundary condition"
v_salt_north.field = "salt_north, scalar, series"
#v_salt_north.missing_value = grdROMS.fillval
v_salt_north.time = "ocean_time"
v_ssh_west = f1.createVariable('zeta_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh_west.long_name = "free-surface western boundary condition"
v_ssh_west.units = "meter"
v_ssh_west.field = "zeta_west, scalar, series"
#v_ssh_west.missing_value = grdROMS.fillval
v_ssh_west.time = "ocean_time"
v_ssh_east = f1.createVariable('zeta_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh_east.long_name = "free-surface eastern boundary condition"
v_ssh_east.units = "meter"
v_ssh_east.field = "zeta_east, scalar, series"
#v_ssh_east.missing_value = grdROMS.fillval
v_ssh_east.time = "ocean_time"
v_ssh_south = f1.createVariable('zeta_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh_south.long_name = "free-surface southern boundary condition"
v_ssh_south.units = "meter"
v_ssh_south.field = "zeta_south, scalar, series"
#v_ssh_south.missing_value = grdROMS.fillval
v_ssh_south.time = "ocean_time"
v_ssh_north = f1.createVariable('zeta_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh_north.long_name = "free-surface northern boundary condition"
v_ssh_north.units = "meter"
v_ssh_north.field = "zeta_north, scalar, series"
#v_ssh_north.missing_value = grdROMS.fillval
v_ssh_north.time = "ocean_time"
v_u_west = f1.createVariable('u_west', 'f', ('ocean_time', 's_rho', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u_west.long_name = "3D u-momentum western boundary condition"
v_u_west.units = "meter second-1"
v_u_west.field = "u_west, scalar, series"
#v_u_west.missing_value = grdROMS.fillval
v_u_west.time = "ocean_time"
v_u_east = f1.createVariable('u_east', 'f', ('ocean_time', 's_rho', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u_east.long_name = "3D u-momentum eastern boundary condition"
v_u_east.units = "meter second-1"
v_u_east.field = "u_east, scalar, series"
#v_u_east.missing_value = grdROMS.fillval
v_u_east.time = "ocean_time"
v_u_south = f1.createVariable('u_south', 'f', ('ocean_time', 's_rho', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u_south.long_name = "3D u-momentum southern boundary condition"
v_u_south.units = "meter second-1"
v_u_south.field = "u_south, scalar, series"
#v_u_south.missing_value = grdROMS.fillval
v_u_south.time = "ocean_time"
v_u_north = f1.createVariable('u_north', 'f', ('ocean_time', 's_rho', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u_north.long_name = "3D u-momentum northern boundary condition"
v_u_north.units = "meter second-1"
v_u_north.field = "u_north, scalar, series"
#v_u_north.missing_value = grdROMS.fillval
v_u_north.time = "ocean_time"
v_v_west = f1.createVariable('v_west', 'f', ('ocean_time', 's_rho', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v_west.long_name = "3D v-momentum western boundary condition"
v_v_west.units = "meter second-1"
v_v_west.field = "v_west, scalar, series"
#v_v_west.missing_value = grdROMS.fillval
v_v_west.time = "ocean_time"
v_v_east = f1.createVariable('v_east', 'f', ('ocean_time', 's_rho', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v_east.long_name = "3D v-momentum eastern boundary condition"
v_v_east.units = "meter second-1"
v_v_east.field = "v_east, scalar, series"
#v_v_east.missing_value = grdROMS.fillval
v_v_east.time = "ocean_time"
v_v_south = f1.createVariable('v_south', 'f', ('ocean_time', 's_rho', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v_south.long_name = "3D v-momentum southern boundary condition"
v_v_south.units = "meter second-1"
v_v_south.field = "v_south, scalar, series"
#v_v_south.missing_value = grdROMS.fillval
v_v_south.time = "ocean_time"
v_v_north = f1.createVariable('v_north', 'f', ('ocean_time', 's_rho', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v_north.long_name = "3D v-momentum northern boundary condition"
v_v_north.units = "meter second-1"
v_v_north.field = "v_north, scalar, series"
#v_v_north.missing_value = grdROMS.fillval
v_v_north.time = "ocean_time"
v_vbar_west = f1.createVariable('vbar_west', 'f', ('ocean_time', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar_west.long_name = "2D v-momentum western boundary condition"
v_vbar_west.units = "meter second-1"
v_vbar_west.field = "vbar_west, scalar, series"
#v_vbar_west.missing_value = grdROMS.fillval
v_vbar_west.time = "ocean_time"
v_vbar_east = f1.createVariable('vbar_east', 'f', ('ocean_time', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar_east.long_name = "2D v-momentum eastern boundary condition"
v_vbar_east.units = "meter second-1"
v_vbar_east.field = "vbar_east, scalar, series"
#v_vbar_east.missing_value = grdROMS.fillval
v_vbar_east.time = "ocean_time"
v_vbar_south = f1.createVariable('vbar_south', 'f', ('ocean_time', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar_south.long_name = "2D v-momentum southern boundary condition"
v_vbar_south.units = "meter second-1"
v_vbar_south.field = "vbar_south, scalar, series"
#v_vbar_south.missing_value = grdROMS.fillval
v_vbar_south.time = "ocean_time"
v_vbar_north = f1.createVariable('vbar_north', 'f', ('ocean_time', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar_north.long_name = "2D v-momentum northern boundary condition"
v_vbar_north.units = "meter second-1"
v_vbar_north.field = "vbar_north, scalar, series"
#v_vbar_north.missing_value = grdROMS.fillval
v_vbar_north.time = "ocean_time"
v_ubar_west = f1.createVariable('ubar_west', 'f', ('ocean_time', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar_west.long_name = "2D u-momentum western boundary condition"
v_ubar_west.units = "meter second-1"
v_ubar_west.field = "ubar_west, scalar, series"
# v_ubar_west.missing_value = grdROMS.fillval
v_ubar_west.time = "ocean_time"
v_ubar_east = f1.createVariable('ubar_east', 'f', ('ocean_time', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar_east.long_name = "2D u-momentum eastern boundary condition"
v_ubar_east.units = "meter second-1"
v_ubar_east.field = "ubar_east, scalar, series"
#v_ubar_east.missing_value = grdROMS.fillval
v_ubar_east.time = "ocean_time"
v_ubar_south = f1.createVariable('ubar_south', 'f', ('ocean_time', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar_south.long_name = "2D u-momentum southern boundary condition"
v_ubar_south.units = "meter second-1"
v_ubar_south.field = "ubar_south, scalar, series"
#v_ubar_south.missing_value = grdROMS.fillval
v_ubar_south.time = "ocean_time"
v_ubar_north = f1.createVariable('ubar_north', 'f', ('ocean_time', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar_north.long_name = "2D u-momentum northern boundary condition"
v_ubar_north.units = "meter second-1"
v_ubar_north.field = "ubar_north, scalar, series"
#v_ubar_north.missing_value = grdROMS.fillval
v_ubar_north.time = "ocean_time"
if confM2R.writebcg:
directions=['east','west','north','south']
dimens=['eta_rho','eta_rho','xi_rho','xi_rho']
lndirections=['eastern','western','northern','southern']
for currentdir,lndirection,dim in zip(directions, lndirections,dimens):
currentvar='O3_c_'+currentdir
longname="carbonate/total dissolved inorganic carbon {} boundary condition".format(lndirection)
O3_c = f1.createVariable(currentvar, 'f', ('ocean_time', 's_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
O3_c.long_name = longname
O3_c.field = "{}, scalar, series".format(currentvar)
O3_c.units = "mmol C/m^3"
currentvar='O3_TA_'+currentdir
longname="carbonate/bioalkalinity {} boundary condition".format(lndirection)
O3_ta = f1.createVariable(currentvar, 'f', ('ocean_time', 's_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
O3_ta.long_name = longname
O3_ta.field = "{}, scalar, series".format(currentvar)
O3_ta.units = "umol/kg"
currentvar='N1_p_'+currentdir
longname="phosphate/phosphorus {} boundary condition".format(lndirection)
N1_p = f1.createVariable(currentvar, 'f', ('ocean_time','s_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
N1_p.long_name = longname
N1_p.field = "{}, scalar, series".format(currentvar)
N1_p.units = "mmol P/m^3"
currentvar='N3_n_'+currentdir
longname="nitrate/nitrogen {} boundary condition".format(lndirection)
N3_n = f1.createVariable(currentvar, 'f', ('ocean_time','s_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
N3_n.long_name = longname
N3_n.field = "{}, scalar, series".format(currentvar)
N3_n.units = "mmol N/m^3"
currentvar='N5_s_'+currentdir
longname="silicate/silicate {} boundary condition".format(lndirection)
N5_s = f1.createVariable(currentvar, 'f', ('ocean_time','s_rho', dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
N5_s.long_name = longname
N5_s.field = "{}, scalar, series".format(currentvar)
N5_s.units = "mmol Si/m^3"
currentvar='O2_o_'+currentdir
longname="oxygen/oxygen {} boundary condition".format(lndirection)
O2_o = f1.createVariable(currentvar, 'f', ('ocean_time', 's_rho',dim,), zlib=myzlib,
fill_value=grdROMS.fillval)
O2_o.long_name = longname
O2_o.field = "{}, scalar, series".format(currentvar)
O2_o.units = "mmol O_2/m^3"
if confM2R.writeice:
ageice_west = f1.createVariable('ageice_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice_west.long_name = "time-averaged age of the ice western boundary conditions"
ageice_west.units = "years"
ageice_west.time = "ocean_time"
ageice_west.field = "ice age, scalar, series"
#ageice_west.missing_value = grdROMS.fillval
ageice_east = f1.createVariable('ageice_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice_east.long_name = "time-averaged age of the ice eastern boundary conditions"
ageice_east.units = "years"
ageice_east.time = "ocean_time"
ageice_east.field = "ice age, scalar, series"
#ageice_east.missing_value = grdROMS.fillval
ageice_south = f1.createVariable('ageice_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice_south.long_name = "time-averaged age of the ice southern boundary conditions"
ageice_south.units = "years"
ageice_south.time = "ocean_time"
ageice_south.field = "ice age, scalar, series"
#ageice_south.missing_value = grdROMS.fillval
ageice_north = f1.createVariable('ageice_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice_north.long_name = "time-averaged age of the ice northern boundary conditions"
ageice_north.units = "years"
ageice_north.time = "ocean_time"
ageice_north.field = "ice age, scalar, series"
#ageice_north.missing_value = grdROMS.fillval
# ----------------------------------------
uice_west = f1.createVariable('uice_west', 'f', ('ocean_time', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice_west.long_name = "time-averaged age of the u-component of ice velocity western boundary conditions"
uice_west.units = "meter second-1"
uice_west.time = "ocean_time"
uice_west.field = "u-component of ice velocity, scalar, series"
#uice_west.missing_value = grdROMS.fillval
uice_east = f1.createVariable('uice_east', 'f', ('ocean_time', 'eta_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice_east.long_name = "time-averaged age of the u-component of ice velocity eastern boundary conditions"
uice_east.units = "meter second-1"
uice_east.time = "ocean_time"
uice_east.field = "u-component of ice velocity, scalar, series"
#uice_east.missing_value = grdROMS.fillval
uice_south = f1.createVariable('uice_south', 'f', ('ocean_time', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice_south.long_name = "time-averaged age of the u-component of ice velocity southern boundary conditions"
uice_south.units = "meter second-1"
uice_south.time = "ocean_time"
uice_south.field = "u-component of ice velocity, scalar, series"
#uice_south.missing_value = grdROMS.fillval
uice_north = f1.createVariable('uice_north', 'f', ('ocean_time', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice_north.long_name = "time-averaged age of the u-component of ice velocity northern boundary conditions"
uice_north.units = "meter second-1"
uice_north.time = "ocean_time"
uice_north.field = "u-component of ice velocity, scalar, series"
#uice_north.missing_value = grdROMS.fillval
# ----------------------------------------
vice_west = f1.createVariable('vice_west', 'f', ('ocean_time', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice_west.long_name = "time-averaged age of the v-component of ice velocity western boundary conditions"
vice_west.units = "meter second-1"
uice_west.time = "ocean_time"
vice_west.field = "v-component of ice velocity, scalar, series"
#vice_west.missing_value = grdROMS.fillval
vice_east = f1.createVariable('vice_east', 'f', ('ocean_time', 'eta_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice_east.long_name = "time-averaged age of the v-component of ice velocity eastern boundary conditions"
vice_east.units = "meter second-1"
vice_east.time = "ocean_time"
vice_east.field = "v-component of ice velocity, scalar, series"
#vice_east.missing_value = grdROMS.fillval
vice_south = f1.createVariable('vice_south', 'f', ('ocean_time', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice_south.long_name = "time-averaged age of the v-component of ice velocity southern boundary conditions"
vice_south.units = "meter second-1"
vice_south.time = "ocean_time"
vice_south.field = "v-component of ice velocity, scalar, series"
#vice_south.missing_value = grdROMS.fillval
vice_north = f1.createVariable('vice_north', 'f', ('ocean_time', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice_north.long_name = "time-averaged age of the u-component of ice velocity northern boundary conditions"
vice_north.units = "meter second-1"
vice_north.time = "ocean_time"
vice_north.field = "v-component of ice velocity, scalar, series"
#vice_north.missing_value = grdROMS.fillval
# ----------------------------------------
aice_west = f1.createVariable('aice_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice_west.long_name = "time-averaged fraction of cell covered by ice western boundary conditions"
aice_west.units = "%"
aice_west.time = "ocean_time"
aice_west.field = "ice concentration, scalar, series"
#aice_west.missing_value = grdROMS.fillval
aice_east = f1.createVariable('aice_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice_east.long_name = "time-averaged fraction of cell covered by ice eastern boundary conditions"
aice_east.units = "%"
aice_east.time = "ocean_time"
aice_east.field = "ice concentration, scalar, series"
#aice_east.missing_value = grdROMS.fillval
aice_south = f1.createVariable('aice_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice_south.long_name = "time-averaged fraction of cell covered by ice southern boundary conditions"
aice_south.units = "%"
aice_south.time = "ocean_time"
aice_south.field = "ice concentration, scalar, series"
#aice_south.missing_value = grdROMS.fillval
aice_north = f1.createVariable('aice_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice_north.long_name = "time-averaged fraction of cell covered by ice northern boundary conditions"
aice_north.units = "%"
aice_north.time = "ocean_time"
aice_north.field = "ice concentration, scalar, series"
#aice_north.missing_value = grdROMS.fillval
# ----------------------------------------
hice_west = f1.createVariable('hice_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice_west.long_name = "time-averaged ice thickness in cell western boundary conditions"
hice_west.units = "meter"
hice_west.time = "ocean_time"
hice_west.field = "ice thickness, scalar, series"
#hice_west.missing_value = grdROMS.fillval
hice_east = f1.createVariable('hice_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice_east.long_name = "time-averaged ice thickness in cell eastern boundary conditions"
hice_east.units = "meter"
hice_east.time = "ocean_time"
hice_east.field = "ice thickness, scalar, series"
#hice_east.missing_value = grdROMS.fillval
hice_south = f1.createVariable('hice_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice_south.long_name = "time-averaged ice thickness in cell southern boundary conditions"
hice_south.units = "meter"
hice_south.time = "ocean_time"
hice_south.field = "ice thickness, scalar, series"
#hice_south.missing_value = grdROMS.fillval
hice_north = f1.createVariable('hice_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice_north.long_name = "time-averaged ice thickness in cell northern boundary conditions"
hice_north.units = "meter"
hice_north.time = "ocean_time"
hice_north.field = "ice thickness, scalar, series"
#hice_north.missing_value = grdROMS.fillval
# ----------------------------------------
snow_thick_west = f1.createVariable('snow_thick_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick_west.long_name = "time-averaged ice thickness in cell western boundary conditions"
snow_thick_west.units = "meter"
snow_thick_west.time = "ocean_time"
snow_thick_west.field = "snow thickness, scalar, series"
#snow_thick_west.missing_value = grdROMS.fillval
snow_thick_east = f1.createVariable('snow_thick_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick_east.long_name = "time-averaged ice thickness in cell eastern boundary conditions"
snow_thick_east.units = "meter"
snow_thick_east.time = "ocean_time"
snow_thick_east.field = "snow thickness, scalar, series"
#snow_thick_east.missing_value = grdROMS.fillval
snow_thick_south = f1.createVariable('snow_thick_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick_south.long_name = "time-averaged ice thickness in cell southern boundary conditions"
snow_thick_south.units = "meter"
snow_thick_south.time = "ocean_time"
snow_thick_south.field = "snow thickness, scalar, series"
#snow_thick_south.missing_value = grdROMS.fillval
snow_thick_north = f1.createVariable('snow_thick_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick_north.long_name = "time-averaged ice thickness in cell northern boundary conditions"
snow_thick_north.units = "meter"
snow_thick_north.time = "ocean_time"
snow_thick_north.field = "snow thickness, scalar, series"
#snow_thick_north.missing_value = grdROMS.fillval
# ----------------------------------------
ti_west = f1.createVariable('ti_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti_west.long_name = "time-averaged interior ice temperature cell western boundary conditions"
ti_west.units = "degrees Celcius"
ti_west.time = "ocean_time"
ti_west.field = "interior temperature, scalar, series"
#ti_west.missing_value = grdROMS.fillval
ti_east = f1.createVariable('ti_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti_east.long_name = "time-averaged interior ice temperature eastern boundary conditions"
ti_east.units = "degrees Celcius"
ti_east.time = "ocean_time"
ti_east.field = "interior temperature, scalar, series"
#ti_east.missing_value = grdROMS.fillval
ti_south = f1.createVariable('ti_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti_south.long_name = "time-averaged interior ice temperature southern boundary conditions"
ti_south.units = "degrees Celcius"
ti_south.time = "ocean_time"
ti_south.field = "interior temperature, scalar, series"
#ti_south.missing_value = grdROMS.fillval
ti_north = f1.createVariable('ti_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti_north.long_name = "time-averaged interior ice temperature northern boundary conditions"
ti_north.units = "degrees Celcius"
ti_north.time = "ocean_time"
ti_north.field = "interior temperature, scalar, series"
#ti_north.missing_value = grdROMS.fillval
# ----------------------------------------
sfwat_west = f1.createVariable('sfwat_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat_west.long_name = "time-averaged surface melt water thickness on ice western boundary conditions"
sfwat_west.units = "meter"
sfwat_west.time = "ocean_time"
sfwat_west.field = "melt water thickness, scalar, series"
#sfwat_west.missing_value = grdROMS.fillval
sfwat_east = f1.createVariable('sfwat_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat_east.long_name = "time-averaged surface melt water thickness on ice eastern boundary conditions"
sfwat_east.units = "meter"
sfwat_east.time = "ocean_time"
sfwat_east.field = "melt water thickness, scalar, series"
#sfwat_east.missing_value = grdROMS.fillval
sfwat_south = f1.createVariable('sfwat_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat_south.long_name = "time-averaged surface melt water thickness on ice southern boundary conditions"
sfwat_south.units = "meter"
sfwat_south.time = "ocean_time"
sfwat_south.field = "melt water thickness, scalar, series"
#sfwat_south.missing_value = grdROMS.fillval
sfwat_north = f1.createVariable('sfwat_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat_north.long_name = "time-averaged surface melt water thickness on ice northern boundary conditions"
sfwat_north.units = "meter"
sfwat_north.time = "ocean_time"
sfwat_north.field = "melt water thickness, scalar, series"
#sfwat_north.missing_value = grdROMS.fillval
# ----------------------------------------
tisrf_west = f1.createVariable('tisrf_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf_west.long_name = "time-averaged temperature of ice surfacewestern boundary conditions"
tisrf_west.units = "degrees Celcius"
tisrf_west.time = "ocean_time"
tisrf_west.field = "surface temperature, scalar, series"
#tisrf_west.missing_value = grdROMS.fillval
tisrf_east = f1.createVariable('tisrf_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf_east.long_name = "time-averaged temperature of ice surface eastern boundary conditions"
tisrf_east.units = "degrees Celcius"
tisrf_east.time = "ocean_time"
tisrf_east.field = "surface temperature, scalar, series"
#tisrf_east.missing_value = grdROMS.fillval
tisrf_south = f1.createVariable('tisrf_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf_south.long_name = "time-averaged temperature of ice surface southern boundary conditions"
tisrf_south.units = "degrees Celcius"
tisrf_south.time = "ocean_time"
tisrf_south.field = "surface temperature, scalar, series"
#tisrf_south.missing_value = grdROMS.fillval
tisrf_north = f1.createVariable('tisrf_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf_north.long_name = "time-averaged temperature of ice surface northern boundary conditions"
tisrf_north.units = "degrees Celcius"
tisrf_north.time = "ocean_time"
tisrf_north.field = "surface temperature, scalar, series"
#tisrf_north.missing_value = grdROMS.fillval
# ----------------------------------------
sig11_west = f1.createVariable('sig11_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11_west.long_name = "time-averaged internal ice stress 11 component boundary conditions"
sig11_west.units = "Newton meter-1"
sig11_west.time = "ocean_time"
sig11_west.field = "ice stress 11, scalar, series"
#sig11_west.missing_value = grdROMS.fillval
sig11_east = f1.createVariable('sig11_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11_east.long_name = "time-averaged internal ice stress 11 component eastern boundary conditions"
sig11_east.units = "Newton meter-1"
sig11_east.time = "ocean_time"
sig11_east.field = "ice stress 11, scalar, series"
#sig11_east.missing_value = grdROMS.fillval
sig11_south = f1.createVariable('sig11_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11_south.long_name = "time-averaged internal ice stress 11 componentsouthern boundary conditions"
sig11_south.units = "Newton meter-1"
sig11_south.time = "ocean_time"
sig11_south.field = "ice stress 11, scalar, series"
#sig11_south.missing_value = grdROMS.fillval
sig11_north = f1.createVariable('sig11_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11_north.long_name = "time-averaged internal ice stress 11 component northern boundary conditions"
sig11_north.units = "Newton meter-1"
sig11_north.time = "ocean_time"
sig11_north.field = "ice stress 11, scalar, series"
#sig11_north.missing_value = grdROMS.fillval
# ----------------------------------------
sig12_west = f1.createVariable('sig12_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12_west.long_name = "time-averaged internal ice stress 12 component boundary conditions"
sig12_west.units = "Newton meter-1"
sig12_west.time = "ocean_time"
sig12_west.field = "ice stress 12, scalar, series"
#sig12_west.missing_value = grdROMS.fillval
sig12_east = f1.createVariable('sig12_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12_east.long_name = "time-averaged internal ice stress 12 component eastern boundary conditions"
sig12_east.units = "Newton meter-1"
sig12_east.time = "ocean_time"
sig12_east.field = "ice stress 12, scalar, series"
#sig12_east.missing_value = grdROMS.fillval
sig12_south = f1.createVariable('sig12_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12_south.long_name = "time-averaged internal ice stress 12 componentsouthern boundary conditions"
sig12_south.units = "Newton meter-1"
sig12_south.time = "ocean_time"
sig12_south.field = "ice stress 12, scalar, series"
#sig12_south.missing_value = grdROMS.fillval
sig12_north = f1.createVariable('sig12_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12_north.long_name = "time-averaged internal ice stress 12 component northern boundary conditions"
sig12_north.units = "Newton meter-1"
sig12_north.time = "ocean_time"
sig12_north.field = "ice stress 12, scalar, series"
#sig12_north.missing_value = grdROMS.fillval
# ----------------------------------------
sig22_west = f1.createVariable('sig22_west', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22_west.long_name = "time-averaged internal ice stress 22 component boundary conditions"
sig22_west.units = "Newton meter-1"
sig22_west.time = "ocean_time"
sig22_west.field = "ice stress 22, scalar, series"
#sig22_west.missing_value = grdROMS.fillval
sig22_east = f1.createVariable('sig22_east', 'f', ('ocean_time', 'eta_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22_east.long_name = "time-averaged internal ice stress 22 component eastern boundary conditions"
sig22_east.units = "Newton meter-1"
sig22_east.time = "ocean_time"
sig22_east.field = "ice stress 22, scalar, series"
#sig22_east.missing_value = grdROMS.fillval
sig22_south = f1.createVariable('sig22_south', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22_south.long_name = "time-averaged internal ice stress 22 componentsouthern boundary conditions"
sig22_south.units = "Newton meter-1"
sig22_south.time = "ocean_time"
sig22_south.field = "ice stress 22, scalar, series"
#sig22_south.missing_value = grdROMS.fillval
sig22_north = f1.createVariable('sig22_north', 'f', ('ocean_time', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22_north.long_name = "time-averaged internal ice stress 22 component northern boundary conditions"
sig22_north.units = "Newton meter-1"
sig22_north.time = "ocean_time"
sig22_north.field = "ice stress 22, scalar, series"
#sig22_north.missing_value = grdROMS.fillval
# ----------------------------------------
f1.close()
def create_searise_grid(filename, grid_spacing, **kwargs):
'''
Create dummy grid description
'''
if 'fileformat' not in kwargs.keys():
fileformat = 'NETCDF4'
else:
fileformat = str.upper(kwargs['fileformat'])
xdim = 'x'
ydim = 'y'
# define output grid, these are the extents of the Bamber domain
e0 = -800000.0
n0 = -3400000.0
e1 = 700000.0
n1 = -600000.0
# Shift to cell centers
e0 += grid_spacing / 2
n0 += grid_spacing / 2
e1 -= grid_spacing / 2
n1 -= grid_spacing / 2
de = dn = grid_spacing # m
M = int((e1 - e0) / de) + 1
N = int((n1 - n0) / dn) + 1
easting = np.linspace(e0, e1, M)
northing = np.linspace(n0, n1, N)
ee, nn = np.meshgrid(easting, northing)
# Set up SeaRISE Projection
projection = "+proj=stere +ellps=WGS84 +datum=WGS84 +lon_0=-39 +lat_0=90 +lat_ts=71 +units=m"
proj = Proj(projection)
lon, lat = proj(ee, nn, inverse=True)
# number of grid corners
grid_corners = 4
# grid corner dimension name
grid_corner_dim_name = "nv4"
# array holding x-component of grid corners
gc_easting = np.zeros((M, grid_corners))
# array holding y-component of grid corners
gc_northing = np.zeros((N, grid_corners))
# array holding the offsets from the cell centers
# in x-direction (counter-clockwise)
de_vec = np.array([-de / 2, de / 2, de / 2, -de / 2])
# array holding the offsets from the cell centers
# in y-direction (counter-clockwise)
dn_vec = np.array([-dn / 2, -dn / 2, dn / 2, dn / 2])
# array holding lat-component of grid corners
gc_lat = np.zeros((N, M, grid_corners))
# array holding lon-component of grid corners
gc_lon = np.zeros((N, M, grid_corners))
for corner in range(0, grid_corners):
## grid_corners in x-direction
gc_easting[:, corner] = easting + de_vec[corner]
# grid corners in y-direction
gc_northing[:, corner] = northing + dn_vec[corner]
# meshgrid of grid corners in x-y space
gc_ee, gc_nn = np.meshgrid(
gc_easting[:, corner], gc_northing[:, corner])
# project grid corners from x-y to lat-lon space
gc_lon[:, :, corner], gc_lat[:, :, corner] = proj(
gc_ee, gc_nn, inverse=True)
nc = CDF(filename, 'w', format=fileformat)
nc.createDimension(xdim, size=easting.shape[0])
nc.createDimension(ydim, size=northing.shape[0])
var = xdim
var_out = nc.createVariable(var, 'f', dimensions=(xdim))
var_out.axis = xdim
var_out.long_name = "X-coordinate in Cartesian system"
var_out.standard_name = "projection_x_coordinate"
var_out.units = "meters"
var_out[:] = easting
var = ydim
var_out = nc.createVariable(var, 'f', dimensions=(ydim))
var_out.axis = ydim
var_out.long_name = "Y-coordinate in Cartesian system"
var_out.standard_name = "projection_y_coordinate"
var_out.units = "meters"
var_out[:] = northing
var = 'lon'
var_out = nc.createVariable(var, 'f', dimensions=(ydim, xdim))
var_out.units = "degrees_east"
var_out.valid_range = -180., 180.
var_out.standard_name = "longitude"
var_out.bounds = "lon_bnds"
var_out[:] = lon
var = 'lat'
var_out = nc.createVariable(var, 'f', dimensions=(ydim, xdim))
var_out.units = "degrees_north"
var_out.valid_range = -90., 90.
var_out.standard_name = "latitude"
var_out.bounds = "lat_bnds"
var_out[:] = lat
nc.createDimension(grid_corner_dim_name, size=grid_corners)
var = 'lon_bnds'
# Create variable 'lon_bnds'
var_out = nc.createVariable(
var, 'f', dimensions=(ydim, xdim, grid_corner_dim_name))
# Assign units to variable 'lon_bnds'
var_out.units = "degreesE"
# Assign values to variable 'lon_nds'
var_out[:] = gc_lon
var = 'lat_bnds'
# Create variable 'lat_bnds'
var_out = nc.createVariable(
var, 'f', dimensions=(ydim, xdim, grid_corner_dim_name))
# Assign units to variable 'lat_bnds'
var_out.units = "degreesN"
# Assign values to variable 'lat_bnds'
var_out[:] = gc_lat
var = 'dummy'
var_out = nc.createVariable(
var,
'f',
dimensions=(
"y",
"x"),
fill_value=-2e9)
var_out.units = "meters"
var_out.long_name = "Just A Dummy"
var_out.comment = "This is just a dummy variable for CDO."
var_out.grid_mapping = "mapping"
var_out.coordinates = "lon lat"
var_out[:] = 0.
mapping = nc.createVariable("mapping", 'c')
mapping.ellipsoid = "WGS84"
mapping.false_easting = 0.
mapping.false_northing = 0.
mapping.grid_mapping_name = "polar_stereographic"
mapping.latitude_of_projection_origin = 90.
mapping.standard_parallel = 71.
mapping.straight_vertical_longitude_from_pole = -39.
from time import asctime
historystr = 'Created ' + asctime() + '\n'
nc.history = historystr
nc.proj4 = projection
nc.Conventions = 'CF-1.5'
nc.close()
def create_nc(filein):
''' Creates the NetCDF file to save the final averages
in.
'''
filedir = filein[:-26]+'monthly_means/'
filename = filein[-26:-20]+'.monthlymean.theta.nc'
f = Dataset(filedir+filename,'w')
# Create dimensions
time = f.createDimension('time',None)
z_hybrid_height = f.createDimension('z_hybrid_height',180)
latitude = f.createDimension('latitude',768)
longitude = f.createDimension('longitude',1024)
bound = f.createDimension('bound',2)
# Create variables (added s on the end to differentiate between dimensions
# and variables)
times = f.createVariable('time','f4',('time',))
z_hybrid_heights = f.createVariable('z_hybrid_height','f4',
('z_hybrid_height',))
latitudes = f.createVariable('latitude','f4',('latitude',))
bounds_latitude = f.createVariable('bounds_latitude','f8',
('latitude','bound',))
longitudes = f.createVariable('longitude','f4',('longitude',))
bounds_longitude = f.createVariable('bounds_longitude','f8',
('longitude','bound',))
u = f.createVariable('theta','f4',('time','z_hybrid_height','latitude',
'longitude',),zlib=True)
# Add in attributes
f.Conventions = 'CF-1.6'
times.units = 'months since 1991-03-01 00:00:00'
times.standard_name = 'time'
times.calendar = '360_day'
times.axis = 'T'
z_hybrid_heights.positive = 'up'
z_hybrid_heights.long_name = 'atmosphere hybrid height coordinate'
z_hybrid_heights.standard_name = 'atmosphere_hybrid_height_coordinate'
z_hybrid_heights.units = 'm'
z_hybrid_heights.axis = 'Z'
latitudes.bounds = 'bounds_latitude'
latitudes.units = 'degrees_north'
latitudes.standard_name = 'latitude'
latitudes.point_spacing = 'even'
latitudes.axis = 'Y'
longitudes.bounds = 'bounds_longitude'
longitudes.modulo = 360.
longitudes.point_spacing = 'even'
longitudes.standard_name = 'longitude'
longitudes.units = 'degrees_east'
longitudes.axis = 'X'
longitudes.topology = 'circular'
u.long_name = 'THETA'
u.standard_name = 'air_potential_temperature'
u.units = 'K'
u.missing_value = -1.073742e+099
# need to add in a bit that saves the values of time, lat and lon
f2 = Dataset(filein)
lat = f2.variables['latitude']
lon = f2.variables['longitude']
height = f2.variables['z_hybrid_height']
latitudes[:] = lat[:]
longitudes[:] = lon[:]
z_hybrid_heights[:] = height[:]
f.close()
f2.close()
def create_uGrid_ncdf(filename,
nMesh2_node, nMesh2_edge, nMesh2_face, nMaxMesh2_face_nodes,
Mesh2_edge_nodes, Mesh2_edge_faces, Mesh2_face_nodes, Mesh2_face_edges,
Mesh2_node_x, Mesh2_node_y, Mesh2_edge_x, Mesh2_edge_y,
Mesh2_face_x, Mesh2_face_y, Mesh2_face_center_x, Mesh2_face_center_y,
Mesh2_face_area=None,
Mesh2_edge_x_bnd=None, Mesh2_edge_y_bnd=None,
Mesh2_face_x_bnd=None, Mesh2_face_y_bnd=None,
coord_type='geographic',
dim_nMesh2_layer2d=1, dim_nMesh2_layer3d=1, dim_nMesh2_class_names_strlen=20, dim_nMesh2_suspension_classes=1,
start_index=0,
log=True):
'''
Function creates a NETCDF4 file. Data is stored in accordance with
BAW convention for 2D Unstructured Grid (http://www.baw.de/methoden/index.php5/NetCDF_Unstrukturiertes_Gitter)
input:
filename - string, containing filename of netcdf file to be created.
nMesh2_node, nMesh2_edge, nMesh2_face - integers, indicating number of nodes/edges/faces in a grid
nMaxMesh2_face_nodes - integer, showing maximum number of nodes/edges in a face (could be 3 or 4)
Mesh2_edge_nodes, Mesh2_edge_faces, Mesh2_face_nodes, Mesh2_face_edges, |
Mesh2_node_x, Mesh2_node_y, Mesh2_edge_x, Mesh2_edge_y, | => 1D numpy arrays with data
Mesh2_face_x, Mesh2_face_y, Mesh2_face_center_x, Mesh2_face_center_y, |
Mesh2_face_area |
coord_type - string indicating in which variable to store passed data, in x,y or in lon,lat
by default - 'geographic'
'cartesian' <> 'geographic'
'''
# --------------------------------------------------
# Creating ncdf
# --------------------------------------------------
root_grp = Dataset(filename, mode='w', format='NETCDF4')
root_grp.title = 'mossco >>> uGrid conversion'
root_grp.history = 'Createded on ' + time.ctime(time.time())
#root_grp.comment = 'WARNING! Latitude and longitude valueas are stored as X,Y coordinates. Therefore any calculations that involve length or area in X or Y dimension are wrong'
root_grp.Conventions = 'CF-1.6'
#root_grp.institution = 'Bundesanstalt fuer Wasserbau - Federal Waterways Engineering and Research Institute'
root_grp.references = 'http://www.baw.de/ und http://www.baw.de/methoden/index.php5/NetCDF'
#root_grp.source = ''
# --------------------------------------------------
# Creating dimensions
# --------------------------------------------------
root_grp.createDimension('nMesh2_node', nMesh2_node)
root_grp.createDimension('nMesh2_edge', nMesh2_edge)
root_grp.createDimension('nMesh2_face', nMesh2_face)
root_grp.createDimension('nMaxMesh2_face_nodes', nMaxMesh2_face_nodes)
root_grp.createDimension('two', 2)
root_grp.createDimension('three', 3)
root_grp.createDimension('nMesh2_time', 1)
root_grp.createDimension('nMesh2_data_time', None) # None stands for UNLIMITED
if dim_nMesh2_layer2d is not None:
root_grp.createDimension('nMesh2_layer_2d', dim_nMesh2_layer2d)
if dim_nMesh2_layer3d is not None:
root_grp.createDimension('nMesh2_layer_3d', dim_nMesh2_layer3d)
root_grp.createDimension('nMesh2_class_names_strlen', dim_nMesh2_class_names_strlen)
root_grp.createDimension('nMesh2_suspension_classes', dim_nMesh2_suspension_classes)
if coord_type in ['cartesian', 'both'] :
# **********************************************************************************************************************************************
#
# 1) Local coordinates
#
# **********************************************************************************************************************************************
# --------------------------------------------------
# 1.1) NODES
# --------------------------------------------------
ncVar_Mesh2_node_x = root_grp.createVariable('Mesh2_node_x', 'f8', ('nMesh2_node'), fill_value=False)
ncVar_Mesh2_node_x.long_name = 'x-Koordinate der Knoten eines 2D-Gitters'
ncVar_Mesh2_node_x.units = 'm'
ncVar_Mesh2_node_x.name_id = 1650
ncVar_Mesh2_node_x.standard_name = 'projection_x_coordinate'
ncVar_Mesh2_node_x[:] = Mesh2_node_x[:]
ncVar_Mesh2_node_y = root_grp.createVariable('Mesh2_node_y', 'f8', ('nMesh2_node'), fill_value=False)
ncVar_Mesh2_node_y.long_name = 'y-Koordinate der Knoten eines 2D-Gitters'
ncVar_Mesh2_node_y.units = 'm'
ncVar_Mesh2_node_y.name_id = 1651
ncVar_Mesh2_node_y.standard_name = 'projection_y_coordinate'
ncVar_Mesh2_node_y[:] = Mesh2_node_y[:]
# --------------------------------------------------
# 1.2) EDGES
# --------------------------------------------------
ncVar_Mesh2_edge_x = root_grp.createVariable('Mesh2_edge_x', 'f8', ('nMesh2_edge'), fill_value=False)
ncVar_Mesh2_edge_x.long_name = 'x-Koordinate der Kanten eines 2D-Gitters, Kantenmitte'
ncVar_Mesh2_edge_x.units = 'm'
ncVar_Mesh2_edge_x.name_id = 1650
ncVar_Mesh2_edge_x.bounds = 'Mesh2_edge_x_bnd'
ncVar_Mesh2_edge_x.standard_name = 'projection_x_coordinate'
ncVar_Mesh2_edge_x[:] = Mesh2_edge_x[:]
ncVar_Mesh2_edge_y = root_grp.createVariable('Mesh2_edge_y', 'f8', ('nMesh2_edge'), fill_value=False)
ncVar_Mesh2_edge_y.long_name = 'y-Koordinate der Kanten eines 2D-Gitters, Kantenmitte'
ncVar_Mesh2_edge_y.units = 'm'
ncVar_Mesh2_edge_y.name_id = 1651
ncVar_Mesh2_edge_y.bounds = 'Mesh2_edge_y_bnd'
ncVar_Mesh2_edge_y.standard_name = 'projection_y_coordinate'
ncVar_Mesh2_edge_y[:] = Mesh2_edge_y[:]
# --------------------------------------------------
# 1.3) FACES
# --------------------------------------------------
ncVar_Mesh2_face_x = root_grp.createVariable('Mesh2_face_x', 'f8', ('nMesh2_face'), fill_value=False)
ncVar_Mesh2_face_x.long_name = 'x-Koordinate der Faces (Polygone) eines 2D-Gitters, Schwerpunkt'
ncVar_Mesh2_face_x.units = 'm'
ncVar_Mesh2_face_x.name_id = 1650
ncVar_Mesh2_face_x.bounds = 'Mesh2_face_x_bnd'
ncVar_Mesh2_face_x.standard_name = 'projection_x_coordinate'
ncVar_Mesh2_face_x[:] = Mesh2_face_x[:]
ncVar_Mesh2_face_y = root_grp.createVariable('Mesh2_face_y', 'f8', ('nMesh2_face'), fill_value=False)
ncVar_Mesh2_face_y.long_name = 'y-Koordinate der Faces (Polygone) eines 2D-Gitters, Schwerpunkt'
ncVar_Mesh2_face_y.units = 'm'
ncVar_Mesh2_face_y.name_id = 1651
ncVar_Mesh2_face_y.bounds = 'Mesh2_face_y_bnd'
ncVar_Mesh2_face_y.standard_name = 'projection_y_coordinate'
ncVar_Mesh2_face_y[:] = Mesh2_face_y[:]
ncVar_Mesh2_face_center_x = root_grp.createVariable('Mesh2_face_center_x', 'f8', ('nMesh2_face'), fill_value=False)
ncVar_Mesh2_face_center_x.long_name = 'x-Koordinate der Faces (Polygone) eines 2D-Gitters, Umkreismittelpunkt'
ncVar_Mesh2_face_center_x.units = 'm'
ncVar_Mesh2_face_center_x.name_id = 1650
ncVar_Mesh2_face_center_x.bounds = 'Mesh2_face_x_bnd'
ncVar_Mesh2_face_center_x.standard_name = 'projection_x_coordinate'
ncVar_Mesh2_face_center_x[:] = Mesh2_face_center_x[:]
ncVar_Mesh2_face_center_y = root_grp.createVariable('Mesh2_face_center_y', 'f8', ('nMesh2_face'), fill_value=False)
ncVar_Mesh2_face_center_y.long_name = 'y-Koordinate der Faces (Polygone) eines 2D-Gitters, Umkreismittelpunkt'
ncVar_Mesh2_face_center_y.units = 'm'
ncVar_Mesh2_face_center_y.name_id = 1651
ncVar_Mesh2_face_center_y.bounds = 'Mesh2_face_y_bnd'
ncVar_Mesh2_face_center_y.standard_name = 'projection_y_coordinate'
ncVar_Mesh2_face_center_y[:] = Mesh2_face_center_y[:]
# --------------------------------------------------
# 1.4) OPTIONAL / BORDERS
# --------------------------------------------------
if Mesh2_edge_x_bnd is not None and Mesh2_edge_y_bnd is not None:
ncVar_Mesh2_edge_x_bnd = root_grp.createVariable('Mesh2_edge_x_bnd', 'f8', ('nMesh2_edge', 'two'), fill_value=False)
ncVar_Mesh2_edge_y_bnd = root_grp.createVariable('Mesh2_edge_y_bnd', 'f8', ('nMesh2_edge', 'two'), fill_value=False)
ncVar_Mesh2_edge_x_bnd[...] = Mesh2_edge_x_bnd
ncVar_Mesh2_edge_y_bnd[...] = Mesh2_edge_y_bnd
if Mesh2_face_x_bnd is not None and Mesh2_face_y_bnd is not None:
ncVar_Mesh2_face_x_bnd = root_grp.createVariable('Mesh2_face_x_bnd', 'f8', ('nMesh2_face', 'nMaxMesh2_face_nodes'), fill_value=-999)
ncVar_Mesh2_face_y_bnd = root_grp.createVariable('Mesh2_face_y_bnd', 'f8', ('nMesh2_face', 'nMaxMesh2_face_nodes'), fill_value=-999)
ncVar_Mesh2_face_x_bnd[...] = Mesh2_face_x_bnd
ncVar_Mesh2_face_y_bnd[...] = Mesh2_face_y_bnd
if coord_type == 'cartesian':
# ------------------------------------------------------------------------------------
# 3.5) Topology
# ------------------------------------------------------------------------------------
ncVar_Mesh2 = root_grp.createVariable('Mesh2', 'i', fill_value=False)
ncVar_Mesh2.long_name = 'UnTRIM Gitternetz, Drei- und Vierecke gemischt, kein SubGrid'
ncVar_Mesh2.cf_role = 'mesh_topology'
ncVar_Mesh2.dimensionality = 2
ncVar_Mesh2.node_coordinates = 'Mesh2_node_x Mesh2_node_y Mesh2_node_lon Mesh2_node_lat'
ncVar_Mesh2.edge_coordinates = 'Mesh2_edge_x Mesh2_edge_y Mesh2_edge_lon Mesh2_edge_lat'
ncVar_Mesh2.face_coordinates = 'Mesh2_face_x Mesh2_face_y Mesh2_face_lon Mesh2_face_lat Mesh2_face_center_x Mesh2_face_center_y Mesh2_face_center_lon Mesh2_face_center_lat'
ncVar_Mesh2.edge_node_connectivity = 'Mesh2_edge_nodes'
ncVar_Mesh2.edge_face_connectivity = 'Mesh2_edge_faces'
ncVar_Mesh2.face_node_connectivity = 'Mesh2_face_nodes'
ncVar_Mesh2.face_edge_connectivity = 'Mesh2_face_edges'
# ------------------------------------------------------------------------------------
# 3.6) Area
# ------------------------------------------------------------------------------------
if Mesh2_face_area is not None:
ncVar_Mesh2_face_area = root_grp.createVariable('Mesh2_face_area', 'f8', ('nMesh2_face'), fill_value=1.e+31)
ncVar_Mesh2_face_area.long_name = 'Zellenflaeche'
ncVar_Mesh2_face_area.units = 'm2'
ncVar_Mesh2_face_area.name_id = 1656
ncVar_Mesh2_face_area.valid_range = [Mesh2_face_area[:].min(), Mesh2_face_area[:].max()]
ncVar_Mesh2_face_area.coordinates = 'Mesh2_face_x Mesh2_face_y Mesh2_face_lon Mesh2_face_lat'
ncVar_Mesh2_face_area.grid_mapping = 'Mesh2_crs'
ncVar_Mesh2_face_area.standard_name = 'cell_area'
ncVar_Mesh2_face_area.mesh = 'Mesh2'
ncVar_Mesh2_face_area.location = 'face'
ncVar_Mesh2_face_area [:] = Mesh2_face_area[:]
elif coord_type in ['geographic', 'both']:
# *********************************************************************************************************************************************
#
# 2) Georaphical coordinates
#
# *********************************************************************************************************************************************
ncVar_Mesh2_crs = root_grp.createVariable('Mesh2_crs', 'i', (), fill_value=False)
ncVar_Mesh2_crs[:] = 4326
ncVar_Mesh2_crs.epsg_code = "EPSG:4326"
ncVar_Mesh2_crs.comment = "LON, LAT : WGS84, EPSG:4326"
ncVar_Mesh2_crs.grid_mapping_name = "latitude_longitude"
#ncVar_Mesh2_crs.grid_mapping_name = "rotated_latitude_longitude"
ncVar_Mesh2_crs.longitude_of_prime_meridian = 0.0
ncVar_Mesh2_crs.semi_major_axis = 6378137.0
ncVar_Mesh2_crs.inverse_flattening = 298.257223563
# --------------------------------------------------
# 2.1) NODES
# --------------------------------------------------
ncVar_Mesh2_node_lon = root_grp.createVariable('Mesh2_node_lon', 'f8', ('nMesh2_node'), fill_value=False)
ncVar_Mesh2_node_lon.long_name = 'geografische Laenge der 2D-Gitter-Knoten'
ncVar_Mesh2_node_lon.units = 'degrees_east'
ncVar_Mesh2_node_lon.name_id = 1653
ncVar_Mesh2_node_lon.standard_name = 'longitude'
ncVar_Mesh2_node_lon[:] = Mesh2_node_x[:]
ncVar_Mesh2_node_lat = root_grp.createVariable('Mesh2_node_lat', 'f8', ('nMesh2_node'), fill_value=False)
ncVar_Mesh2_node_lat.long_name = 'geografische Breite der 2D-Gitter-Knoten'
ncVar_Mesh2_node_lat.units = 'degrees_north'
ncVar_Mesh2_node_lat.name_id = 1652
ncVar_Mesh2_node_lat.standard_name = 'latitude'
ncVar_Mesh2_node_lat[:] = Mesh2_node_y[:]
# --------------------------------------------------
# 2.2) EDGES
# --------------------------------------------------
ncVar_Mesh2_edge_lon = root_grp.createVariable('Mesh2_edge_lon', 'f8', ('nMesh2_edge'), fill_value=False)
ncVar_Mesh2_edge_lon.long_name = 'geografische Laenge der 2D-Gitter-Kanten, Kantenmitte'
ncVar_Mesh2_edge_lon.units = 'degrees_east'
ncVar_Mesh2_edge_lon.name_id = 1653
ncVar_Mesh2_edge_lon.bounds = 'Mesh2_edge_lon_bnd'
ncVar_Mesh2_edge_lon.standard_name = 'longitude'
ncVar_Mesh2_edge_lon[:] = Mesh2_edge_x[:]
ncVar_Mesh2_edge_lat = root_grp.createVariable('Mesh2_edge_lat', 'f8', ('nMesh2_edge'), fill_value=False)
ncVar_Mesh2_edge_lat.long_name = 'geografische Breite der 2D-Gitter-Kanten, Kantenmitte'
ncVar_Mesh2_edge_lat.units = 'degrees_north'
ncVar_Mesh2_edge_lat.name_id = 1652
ncVar_Mesh2_edge_lat.bounds = 'Mesh2_edge_lat_bnd'
ncVar_Mesh2_edge_lat.standard_name = 'latitude'
ncVar_Mesh2_edge_lat[:] = Mesh2_edge_y[:]
# --------------------------------------------------
# 2.3) FACES
# --------------------------------------------------
ncVar_Mesh2_face_lon = root_grp.createVariable('Mesh2_face_lon', 'f8', ('nMesh2_face'), fill_value=False)
ncVar_Mesh2_face_lon.long_name = 'geografische Laenge der 2D-Gitter-Faces (Polygone), Schwerpunkt'
ncVar_Mesh2_face_lon.units = 'degrees_east'
ncVar_Mesh2_face_lon.name_id = 1653
ncVar_Mesh2_face_lon.bounds = 'Mesh2_face_lon_bnd'
ncVar_Mesh2_face_lon.standard_name = 'longitude'
ncVar_Mesh2_face_lon[:] = Mesh2_face_x[:]
ncVar_Mesh2_face_lat = root_grp.createVariable('Mesh2_face_lat', 'f8', ('nMesh2_face'), fill_value=False)
ncVar_Mesh2_face_lat.long_name = 'geografische Breite der 2D-Gitter-Faces (Polygone), Schwerpunkt'
ncVar_Mesh2_face_lat.units = 'degrees_north'
ncVar_Mesh2_face_lat.name_id = 1652
ncVar_Mesh2_face_lat.bounds = 'Mesh2_face_lat_bnd'
ncVar_Mesh2_face_lat.standard_name = 'latitude'
ncVar_Mesh2_face_lat[:] = Mesh2_face_y[:]
ncVar_Mesh2_face_center_lon = root_grp.createVariable('Mesh2_face_center_lon', 'f8', ('nMesh2_face'), fill_value=False)
ncVar_Mesh2_face_center_lon.long_name = 'geografische Laenge der 2D-Gitter-Faces (Polygone), Umkreismittelpunkt'
ncVar_Mesh2_face_center_lon.units = 'degrees_east'
ncVar_Mesh2_face_center_lon.name_id = 1653
ncVar_Mesh2_face_center_lon.standard_name = 'longitude'
ncVar_Mesh2_face_center_lon[:] = Mesh2_face_center_x[:]
ncVar_Mesh2_face_center_lat = root_grp.createVariable('Mesh2_face_center_lat', 'f8', ('nMesh2_face'), fill_value=False)
ncVar_Mesh2_face_center_lat.long_name = 'geografische Breite der 2D-Gitter-faces (Polygone), Umkreismittelpunkt'
ncVar_Mesh2_face_center_lat.units = 'degrees_north'
ncVar_Mesh2_face_center_lat.name_id = 1652
ncVar_Mesh2_face_center_lat.standard_name = 'latitude'
ncVar_Mesh2_face_center_lat[:] = Mesh2_face_center_y[:]
# --------------------------------------------------
# 2.4) OPTIONAL / BORDERS
# --------------------------------------------------
if Mesh2_edge_x_bnd is not None and Mesh2_edge_y_bnd is not None:
ncVar_Mesh2_edge_lon_bnd = root_grp.createVariable('Mesh2_edge_lon_bnd', 'f8', ('nMesh2_edge', 'two'), fill_value=False)
ncVar_Mesh2_edge_lat_bnd = root_grp.createVariable('Mesh2_edge_lat_bnd', 'f8', ('nMesh2_edge', 'two'), fill_value=False)
ncVar_Mesh2_edge_lon_bnd[...] = Mesh2_edge_x_bnd
ncVar_Mesh2_edge_lat_bnd[...] = Mesh2_edge_y_bnd
if Mesh2_face_x_bnd is not None and Mesh2_face_y_bnd is not None:
ncVar_Mesh2_face_lon_bnd = root_grp.createVariable('Mesh2_face_lon_bnd', 'f8', ('nMesh2_face', 'nMaxMesh2_face_nodes'), fill_value=-999)
ncVar_Mesh2_face_lat_bnd = root_grp.createVariable('Mesh2_face_lat_bnd', 'f8', ('nMesh2_face', 'nMaxMesh2_face_nodes'), fill_value=-999)
ncVar_Mesh2_face_lon_bnd[...] = Mesh2_face_x_bnd
ncVar_Mesh2_face_lat_bnd[...] = Mesh2_face_y_bnd
# ------------------------------------------------------------------------------------
# 3.5) Topology
# ------------------------------------------------------------------------------------
ncVar_Mesh2 = root_grp.createVariable('Mesh2', 'i', fill_value=False)
#ncVar_Mesh2.long_name = 'UnTRIM Gitternetz, Drei- und Vierecke gemischt, kein SubGrid'
ncVar_Mesh2.long_name = 'UnTRIM Gitternetz, Vierecke, kein SubGrid'
ncVar_Mesh2.cf_role = 'mesh_topology'
ncVar_Mesh2.dimensionality = 2
ncVar_Mesh2.node_coordinates = 'Mesh2_node_lon Mesh2_node_lat Mesh2_node_x Mesh2_node_y'
ncVar_Mesh2.edge_coordinates = 'Mesh2_edge_lon Mesh2_edge_lat Mesh2_edge_x Mesh2_edge_y'
ncVar_Mesh2.face_coordinates = 'Mesh2_face_lon Mesh2_face_lat Mesh2_face_x Mesh2_face_y Mesh2_face_center_lon Mesh2_face_center_lat Mesh2_face_center_x Mesh2_face_center_y '
ncVar_Mesh2.edge_node_connectivity = 'Mesh2_edge_nodes'
ncVar_Mesh2.edge_face_connectivity = 'Mesh2_edge_faces'
ncVar_Mesh2.face_node_connectivity = 'Mesh2_face_nodes'
ncVar_Mesh2.face_edge_connectivity = 'Mesh2_face_edges'
else:
err_msg = 'passed <coord_type = {0}> is invalid. Choose "cartesian", "geographic" or "both"'.format(coord_type)
raise TypeError(err_msg)
# **************************************************
#
# 3) Topological coordinates
#
# **************************************************
# --------------------------------------------------
# 3.1) EDGE >>> NODES
# --------------------------------------------------
ncVar_Mesh2_edge_nodes = root_grp.createVariable('Mesh2_edge_nodes', 'i', ('nMesh2_edge', 'two'))
ncVar_Mesh2_edge_nodes.long_name = 'Knotenverzeichnis der Kanten, Anfangs- und Endpunkt'
ncVar_Mesh2_edge_nodes.cf_role = 'edge_node_connectivity'
ncVar_Mesh2_edge_nodes.start_index = start_index
ncVar_Mesh2_edge_nodes[:] = Mesh2_edge_nodes[:]
# --------------------------------------------------
# 3.2) EDGE >>> FACES
# --------------------------------------------------
ncVar_Mesh2_edge_faces = root_grp.createVariable('Mesh2_edge_faces', 'i', ('nMesh2_edge', 'two'), fill_value=-999)
ncVar_Mesh2_edge_faces.long_name = 'Face- (Polygon-) Verzeichnis der Kanten, linker und rechter Nachbar'
ncVar_Mesh2_edge_faces.cf_role = 'edge_face_connectivity'
ncVar_Mesh2_edge_faces.start_index = start_index
ncVar_Mesh2_edge_faces[:] = Mesh2_edge_faces[:]
# --------------------------------------------------
# 3.3) FACE >>> NODES
# --------------------------------------------------
ncVar_Mesh2_face_nodes = root_grp.createVariable('Mesh2_face_nodes', 'i', ('nMesh2_face', 'nMaxMesh2_face_nodes'), fill_value=-999)
ncVar_Mesh2_face_nodes.long_name = 'Knotenverzeichnis der Faces (Polygone),entgegen dem Uhrzeigersinn'
ncVar_Mesh2_face_nodes.cf_role = 'face_node_connectivity'
ncVar_Mesh2_face_nodes.start_index = start_index
ncVar_Mesh2_face_nodes[:] = Mesh2_face_nodes[:]
# ------------------------------------------------------------------------------------
# 3.4) FACE >>> EDGES
# ------------------------------------------------------------------------------------
ncVar_Mesh2_face_edges = root_grp.createVariable('Mesh2_face_edges', 'i', ('nMesh2_face', 'nMaxMesh2_face_nodes'), fill_value=-999)
ncVar_Mesh2_face_edges.long_name = 'Kantenverzeichnis der Faces (Polygone),entgegen dem Uhrzeigersinn'
ncVar_Mesh2_face_edges.cf_role = 'face_edge_connectivity'
ncVar_Mesh2_face_edges.start_index = start_index
ncVar_Mesh2_face_edges[:] = Mesh2_face_edges[:]
# --------------------------------------------------
# Closing ncdf
# --------------------------------------------------
root_grp.close()
if log: print 'File created succesfully: %s' % (filename)
def writeclimfile(confM2R, ntime, myvar, data1=None, data2=None, data3=None, data4=None):
if confM2R.myformat == 'NETCDF4':
myzlib = True
else:
myzlib = False
grdROMS = confM2R.grdROMS
if confM2R.grdROMS.ioClimInitialized is False:
confM2R.grdROMS.ioClimInitialized = True
if os.path.exists(confM2R.climname):
os.remove(confM2R.climname)
f1 = Dataset(confM2R.climname, mode='w', format=confM2R.myformat)
f1.title = "Climatology forcing file (CLIM) used for forcing the ROMS model"
f1.description = "Created for grid file: %s" % (confM2R.romsgridpath)
f1.grd_file = "Gridfile: %s" % (confM2R.romsgridpath)
f1.history = "Created " + time.ctime(time.time())
f1.source = "{} ({})".format(confM2R.authorname,confM2R.authoremail)
f1.type = "File in %s format created using MODEL2ROMS" % (confM2R.myformat)
f1.link = "https://github.com/trondkr/model2roms"
f1.Conventions = "CF-1.0"
# Define dimensions
f1.createDimension('xi_rho', grdROMS.xi_rho)
f1.createDimension('eta_rho', grdROMS.eta_rho)
f1.createDimension('xi_u', grdROMS.xi_u)
f1.createDimension('eta_u', grdROMS.eta_u)
f1.createDimension('xi_v', grdROMS.xi_v)
f1.createDimension('eta_v', grdROMS.eta_v)
f1.createDimension('xi_psi', grdROMS.xi_psi)
f1.createDimension('eta_psi', grdROMS.eta_psi)
f1.createDimension('s_rho', len(grdROMS.s_rho))
f1.createDimension('s_w', len(grdROMS.s_w))
if confM2R.isclimatology:
f1.createDimension('clim_time', 12)
else:
f1.createDimension('ocean_time', None)
vnc = f1.createVariable('lon_rho', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of RHO-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_rho
vnc = f1.createVariable('lat_rho', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of RHO-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_rho
vnc = f1.createVariable('lon_u', 'd', ('eta_u', 'xi_u',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of U-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_u
vnc = f1.createVariable('lat_u', 'd', ('eta_u', 'xi_u',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of U-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_u
vnc = f1.createVariable('lon_v', 'd', ('eta_v', 'xi_v',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of V-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_v
vnc = f1.createVariable('lat_v', 'd', ('eta_v', 'xi_v',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of V-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_v
vnc = f1.createVariable('lat_psi', 'd', ('eta_psi', 'xi_psi',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of PSI-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_psi
vnc = f1.createVariable('lon_psi', 'd', ('eta_psi', 'xi_psi',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of PSI-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_psi
vnc = f1.createVariable('h', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Bathymetry at RHO-points'
vnc.units = 'meter'
vnc.field = "bath, scalar"
vnc[:, :] = grdROMS.h
vnc = f1.createVariable('f', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Coriolis parameter at RHO-points'
vnc.units = 'second-1'
vnc.field = "Coriolis, scalar"
vnc[:, :] = grdROMS.f
vnc = f1.createVariable('pm', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'curvilinear coordinate metric in XI'
vnc.units = 'meter-1'
vnc.field = "pm, scalar"
vnc[:, :] = grdROMS.pm
vnc = f1.createVariable('pn', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'curvilinear coordinate metric in ETA'
vnc.units = 'meter-1'
vnc.field = "pn, scalar"
vnc[:, :] = grdROMS.pn
vnc = f1.createVariable('s_rho', 'd', ('s_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate at RHO-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
if grdROMS.vtransform == 2:
vnc.standard_name = "ocean_s_coordinate_g2"
vnc.formula_terms = "s: s_rho C: Cs_r eta: zeta depth: h depth_c: hc"
if grdROMS.vtransform == 1:
vnc.standard_name = "ocean_s_coordinate_g1"
vnc.formula_terms = "s: s_rho C: Cs_r eta: zeta depth: h depth_c: hc"
vnc.field = "s_rho, scalar"
vnc[:] = grdROMS.s_rho
vnc = f1.createVariable('s_w', 'd', ('s_w',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate at W-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
if grdROMS.vtransform == 2:
vnc.standard_name = "ocean_s_coordinate_g2"
vnc.formula_terms = "s: s_w C: Cs_w eta: zeta depth: h depth_c: hc"
if grdROMS.vtransform == 1:
vnc.standard_name = "ocean_s_coordinate_g1"
vnc.formula_terms = "s: s_w C: Cs_w eta: zeta depth: h depth_c: hc"
vnc.field = "s_w, scalar"
vnc[:] = grdROMS.s_w
vnc = f1.createVariable('Cs_r', 'd', ('s_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate stretching curves at RHO-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.field = "s_rho, scalar"
vnc[:] = grdROMS.Cs_rho
vnc = f1.createVariable('Cs_w', 'd', ('s_w',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate stretching curves at W-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.field = "s_w, scalar"
vnc[:] = grdROMS.Cs_w
vnc = f1.createVariable('hc', 'd')
vnc.long_name = "S-coordinate parameter, critical depth";
vnc.units = "meter"
vnc[:] = grdROMS.hc
vnc = f1.createVariable('z_r', 'd', ('s_rho', 'eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "Sigma layer to depth matrix";
vnc.units = "meter"
vnc[:, :, :] = grdROMS.z_r
vnc = f1.createVariable('z_w', 'd', ('s_w', 'eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "Sigma layer to depth matrix";
vnc.units = "meter"
vnc[:, :, :] = grdROMS.z_w
vnc = f1.createVariable('Tcline', 'd')
vnc.long_name = "S-coordinate surface/bottom layer width"
vnc.units = "meter"
vnc[:] = grdROMS.tcline
vnc = f1.createVariable('theta_s', 'd')
vnc.long_name = "S-coordinate surface control parameter"
vnc[:] = grdROMS.theta_s
vnc = f1.createVariable('theta_b', 'd')
vnc.long_name = "S-coordinate bottom control parameter"
vnc[:] = grdROMS.theta_b
vnc = f1.createVariable('angle', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "angle between xi axis and east"
vnc.units = "radian"
vnc[:, :] = grdROMS.angle
# Now start creating variables for regular climatology/bry/init creations
if not confM2R.isclimatology:
v_time = f1.createVariable('ocean_time', 'd', ('ocean_time',), zlib=myzlib, fill_value=grdROMS.fillval)
v_time.long_name = 'seconds since 1948-01-01 00:00:00'
v_time.units = 'seconds since 1948-01-01 00:00:00'
v_time.field = 'time, scalar, series'
if (confM2R.indatatype == "NORESM"):
v_time.calendar = 'noleap'
else:
v_time.calendar = 'standard'
v_u = f1.createVariable('u', 'f', ('ocean_time', 's_rho', 'eta_u', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u.long_name = "u-momentum component"
v_u.units = "meter second-1"
v_u.time = "ocean_time"
v_u.field = "u-velocity, scalar, series"
#v_u.missing_value = grdROMS.fillval
v_v = f1.createVariable('v', 'f', ('ocean_time', 's_rho', 'eta_v', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v.long_name = "v-momentum component"
v_v.units = "meter second-1"
v_v.time = "ocean_time"
v_v.field = "v-velocity, scalar, series"
#v_v.missing_value = grdROMS.fillval
v_salt = f1.createVariable('salt', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt.long_name = "salinity"
v_salt.time = "ocean_time"
v_salt.field = "salinity, scalar, series"
#v_salt.missing_value = grdROMS.fillval
v_temp = f1.createVariable('temp', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp.long_name = "potential temperature"
v_temp.units = "Celsius"
v_temp.time = "ocean_time"
v_temp.field = "temperature, scalar, series"
#v_temp.missing_value = grdROMS.fillval
v_ssh = f1.createVariable('zeta', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh.long_name = "sea level"
v_ssh.units = "meter"
v_ssh.time = "ocean_time"
v_ssh.field = "sea level, scalar, series"
#v_ssh.missing_value = grdROMS.fillval
v_ubar = f1.createVariable('ubar', 'f', ('ocean_time', 'eta_u', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar.long_name = "u-2D momentum"
v_ubar.units = "meter second-1"
v_ubar.time = "ocean_time"
v_ubar.field = "u2-D velocity, scalar, series"
#v_ubar.missing_value = grdROMS.fillval
v_vbar = f1.createVariable('vbar', 'f', ('ocean_time', 'eta_v', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar.long_name = "v-2D momentum"
v_vbar.units = "meter second-1"
v_vbar.time = "ocean_time"
v_vbar.field = "v2-D velocity, scalar, series"
#v_vbar.missing_value = grdROMS.fillval
if confM2R.writeice:
ageice = f1.createVariable('ageice', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice.long_name = "time-averaged age of the ice"
ageice.units = "years"
ageice.time = "ocean_time"
ageice.field = "ice age, scalar, series"
#ageice.missing_value = grdROMS.fillval
uice = f1.createVariable('uice', 'd', ('ocean_time', 'eta_u', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice.long_name = "time-averaged u-component of ice velocity"
uice.units = "meter second-1"
uice.time = "ocean_time"
uice.field = "u-component of ice velocity, scalar, series"
#uice.missing_value = grdROMS.fillval
vice = f1.createVariable('vice', 'd', ('ocean_time', 'eta_v', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice.long_name = "time-averaged v-component of ice velocity"
vice.units = "meter second-1"
vice.time = "ocean_time"
vice.field = "v-component of ice velocity, scalar, series"
#vice.missing_value = grdROMS.fillval
aice = f1.createVariable('aice', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice.long_name = "time-averaged fraction of cell covered by ice"
aice.time = "ocean_time"
aice.field = "ice concentration, scalar, series"
#aice.missing_value = grdROMS.fillval
hice = f1.createVariable('hice', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice.long_name = "time-averaged average ice thickness in cell"
hice.units = "meter"
hice.time = "ocean_time"
hice.field = "ice thickness, scalar, series"
#hice.missing_value = grdROMS.fillval
snow_thick = f1.createVariable('snow_thick', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick.long_name = "time-averaged thickness of snow cover"
snow_thick.units = "meter"
snow_thick.time = "ocean_time"
snow_thick.field = "snow thickness, scalar, series"
#snow_thick.missing_value = grdROMS.fillval
ti = f1.createVariable('ti', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti.long_name = "time-averaged interior ice temperature"
ti.units = "degrees Celcius"
ti.time = "ocean_time"
ti.field = "interior temperature, scalar, series"
#ti.missing_value = grdROMS.fillval
sfwat = f1.createVariable('sfwat', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat.long_name = "time-averaged surface melt water thickness on ice"
sfwat.units = "meter"
sfwat.time = "ocean_time"
sfwat.field = "melt water thickness, scalar, series"
#sfwat.missing_value = grdROMS.fillval
tisrf = f1.createVariable('tisrf', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf.long_name = "time-averaged temperature of ice surface"
tisrf.units = "degrees Celcius"
tisrf.time = "ocean_time"
tisrf.field = "surface temperature, scalar, series"
#tisrf.missing_value = grdROMS.fillval
sig11 = f1.createVariable('sig11', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11.long_name = "time-averaged internal ice stress 11 component"
sig11.units = "Newton meter-1"
sig11.time = "ocean_time"
sig11.field = "ice stress 11, scalar, series"
#sig11.missing_value = grdROMS.fillval
sig12 = f1.createVariable('sig12', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12.long_name = "time-averaged internal ice stress 12 component"
sig12.units = "Newton meter-1"
sig12.time = "ocean_time"
sig12.field = "ice stress 12, scalar, series"
#sig12.missing_value = grdROMS.fillval
sig22 = f1.createVariable('sig22', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22.long_name = "time-averaged internal ice stress 22 component"
sig22.units = "Newton meter-1"
sig22.time = "ocean_time"
sig22.field = "ice stress 22, scalar, series"
#sig22.missing_value = grdROMS.fillval
if confM2R.writebcg:
v_o3_c = f1.createVariable('O3_c', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_o3_c.long_name = "carbonate/total dissolved inorganic carbon"
v_o3_c.time = "ocean_time"
v_o3_c.units = "mmol C/m^3"
v_o3_c.field = "O3_c, scalar, series"
v_o3_ta = f1.createVariable('O3_TA', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_o3_ta.long_name = "carbonate/bioalkalinity"
v_o3_ta.time = "ocean_time"
v_o3_ta.units = "umol/kg"
v_o3_ta.field = "O3_ta, scalar, series"
v_n1_p = f1.createVariable('N1_p', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_n1_p.long_name = "phosphate/phosphorus"
v_n1_p.time = "ocean_time"
v_n1_p.units = "mmol P/m^3"
v_n1_p.field = "N1_p, scalar, series"
v_o2_o = f1.createVariable('O2_o', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_o2_o.long_name = "oxygen/oxygen"
v_o2_o.time = "ocean_time"
v_o2_o.units = "mmol O_2/m^3"
v_o2_o.field = "O2_o, scalar, series"
v_n3_n = f1.createVariable('N3_n', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_n3_n.long_name = "nitrate/nitrogen"
v_n3_n.time = "ocean_time"
v_n3_n.units = "mmol N/m^3"
v_n3_n.field = "N3_n, scalar, series"
v_n5_s = f1.createVariable('N5_s', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_n5_s.long_name = "silicate/silicate"
v_n5_s.time = "ocean_time"
v_n5_s.units = "mmol Si/m^3"
v_n5_s.field = "N5_s, scalar, series"
# If we are creating climatology files with loops every 360 days, then create these variables here
if confM2R.isclimatology:
v_time = f1.createVariable('clim_time', 'd', ('clim_time',), zlib=myzlib, fill_value=grdROMS.fillval)
v_time.units = 'day'
v_time.field = 'time, scalar, series'
v_time.calendar = 'standard'
v_time.cycle_length = 360.
v_salt = f1.createVariable('salt', 'f', ('clim_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt.long_name = "salinity"
v_salt.time = "clim_time"
v_salt.field = "salinity, scalar, series"
#v_salt.missing_value = grdROMS.fillval
v_salt = f1.createVariable('SSS', 'f', ('clim_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt.long_name = "salinity"
v_salt.time = "clim_time"
v_salt.field = "salinity, scalar, series"
#v_salt.missing_value = grdROMS.fillval
v_temp = f1.createVariable('temp', 'f', ('clim_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp.long_name = "potential temperature"
v_temp.units = "Celsius"
v_temp.time = "clim_time"
v_temp.field = "temperature, scalar, series"
#v_temp.missing_value = grdROMS.fillval
else:
f1 = Dataset(confM2R.climname, mode='a', format=confM2R.myformat)
if confM2R.isclimatology is False:
if myvar == confM2R.globalvarnames[0]:
if grdROMS.timeunits[0:7] == "seconds":
print("time units ", grdROMS.timeunits, grdROMS.timeunits[0:7])
f1.variables['ocean_time'][ntime] = grdROMS.time
d = num2date(grdROMS.time, units=f1.variables['ocean_time'].long_name,
calendar=f1.variables['ocean_time'].calendar)
else:
f1.variables['ocean_time'][ntime] = grdROMS.time * 86400.0
d = num2date(grdROMS.time * 86400.0, units=f1.variables['ocean_time'].long_name,
calendar=f1.variables['ocean_time'].calendar)
grdROMS.message = d
if myvar == 'temperature':
f1.variables['temp'][ntime, :, :, :] = data1
if myvar == 'salinity':
f1.variables['salt'][ntime, :, :, :] = data1
if myvar == 'ssh':
f1.variables['zeta'][ntime, :, :] = data1
if myvar == 'vvel':
f1.variables['u'][ntime, :, :, :] = data1
f1.variables['v'][ntime, :, :, :] = data2
f1.variables['ubar'][ntime, :, :] = data3
f1.variables['vbar'][ntime, :, :] = data4
if confM2R.writeice:
if myvar == "ageice":
# print "NOTE! Setting values of ageice to ZERO! (IOWrite.py)"
data1 = np.where(abs(data1) > 100, 0, data1)
f1.variables['ageice'][ntime, :, :] = data1
if myvar == 'uice':
data1 = np.where(abs(data1) > 120, 0, data1)
f1.variables['uice'][ntime, :, :] = data1 * 0.01 # NorESM is cm/s divide by 100 to get m/s
f1.variables['sfwat'][ntime, :, :] = 0.
f1.variables['tisrf'][ntime, :, :] = 0.
f1.variables['ti'][ntime, :, :] = 0.
f1.variables['sig11'][ntime, :, :] = 0.
f1.variables['sig12'][ntime, :, :] = 0.
f1.variables['sig22'][ntime, :, :] = 0.
if confM2R.indatatype == 'GLORYS':
# Special care for GLORYS as dataset does not contain sea ice age and snow thickness
f1.variables['ageice'][ntime, :, :] = 0.
f1.variables['snow_thick'][ntime, :, :] = 0
if myvar == 'vice':
data1 = np.where(abs(data1) > 120, 0, data1)
f1.variables['vice'][ntime, :, :] = data1 * 0.01 # NorESM is cm/s divide by 100 to get m/s
if myvar == 'aice':
data1 = np.where(abs(data1) > 120, 0, data1)
f1.variables['aice'][ntime, :, :] = data1 * 0.01 # NorESM is % divide by 100 to get fraction
if myvar == 'hice':
data1 = np.where(abs(data1) > 10, 0, data1)
# data1 = np.ma.masked_where(abs(data1) > 10, data1)
f1.variables['hice'][ntime, :, :] = data1
if myvar == 'snow_thick':
# data1 = np.ma.masked_where(abs(data1) > 100, data1)
data1 = np.where(abs(data1) > 10, 0, data1)
f1.variables['snow_thick'][ntime, :, :] = data1
if confM2R.writebcg:
if myvar in ['O3_c','O3_TA','N1_p','N3_n','N5_s','O2_o']:
data1 = np.where(abs(data1) < 0, 0, data1)
if confM2R.indatatype=="NORESM":
"""
Multiply the NORESM variable by conversion factors below:
NORESM name NORESM units ERSEM name ERSEM units Conversion factor
dissic [mol C/m3] O3_c [mmol C/m3] 1e3
talk [eq/m3] O3_TA [umol/kg] 1e6/1025
po4 [mol P/m3] N1_p [mmol P/m3] 1e3
no3 [mol N/m3] N3_n [mmol N/m3] 1e3
si [mol Si/m3] N5_s [mmol Si/m3] 1e3
o2 [mol O2/m3] O2_o [mmol O2/m3] 1e3
"""
if myvar=="O3_TA":
data1=data1*1.0e6/1025.
else:
data1=data1*1.0e3
f1.variables[myvar][ntime,:,:,:] = data1
if confM2R.isclimatology:
# Climatological time starts at the 15th of each month
d = datetime(2012, int(ntime) + 1, 1)
tt = d.timetuple()
if myvar == grdROMS.vars[0]:
f1.variables['clim_time'][ntime] = tt.tm_yday + 15
grdROMS.message = tt.tm_yday + 15
if myvar == 'temperature':
f1.variables['temp'][ntime,:,:,:] = data1
if myvar == 'salinity':
f1.variables['salt'][ntime,:,:,:] = data1
f1.variables['SSS'][ntime,:,:,:] = data1
f1.close()
def makenetcdf_(datasetname, lines):
filedate = getlinedate_(lines[0])
ncbytes = None
platform_code = getplatformcode_(datasetname)
filenameroot = "GL_TS_TS_" + getplatformcallsign_(platform_code) + "_" + filedate
# Open a new netCDF file
ncpath = tempfile.gettempdir() + "/" + filenameroot + ".nc"
nc = Dataset(ncpath, format="NETCDF4_CLASSIC", mode="w")
# The DEPTH dimension is singular. Assume 5m for ships
depthdim = nc.createDimension("DEPTH", 1)
# Time, lat and lon dimensions are created per record
timedim = nc.createDimension("TIME", None)
timevar = nc.createVariable("TIME", "d", ("TIME"), fill_value = 999999.0)
timevar.long_name = "Time"
timevar.standard_name = "time"
timevar.units = "days since 1950-01-01T00:00:00Z"
timevar.valid_min = -90000;
timevar.valid_max = 90000;
timevar.axis = "T"
latdim = nc.createDimension("LATITUDE", len(lines))
latvar = nc.createVariable("LATITUDE", "f", ("LATITUDE"),
fill_value = 99999.0)
latvar.long_name = "Latitude of each location"
latvar.standard_name = "latitude"
latvar.units = "degree_north"
latvar.valid_min = -90
latvar.valid_max = 90
latvar.axis = "Y"
latvar.reference = "WGS84"
latvar.coordinate_reference_frame = "urn:ogc:crs:EPSG::4326"
londim = nc.createDimension("LONGITUDE", len(lines))
lonvar = nc.createVariable("LONGITUDE", "f", ("LONGITUDE"),
fill_value = 99999.0)
lonvar.long_name = "Longitude of each location"
lonvar.standard_name = "longitude"
lonvar.units = "degree_east"
lonvar.valid_min = -180
lonvar.valid_max = 180
lonvar.axis = "X"
lonvar.reference = "WGS84"
lonvar.coordinate_reference_frame = "urn:ogc:crs:EPSG::4326"
positiondim = nc.createDimension("POSITION", len(lines))
# Record position bounds
minlon = 180
maxlon = -180
minlat = 90
maxlat = -90
# Fill in dimension variables
print(len(lines))
times = [0] * len(lines)
lats = [0] * len(lines)
lons = [0] * len(lines)
for i in range(0, len(lines)):
fields = str.split(lines[i], ",")
times[i] = maketimefield_(fields[0])
if i == 0:
starttime = maketimeobject_(fields[0])
if i == len(lines) - 1:
endtime = maketimeobject_(fields[0])
lats[i] = float(fields[2])
if lats[i] < minlat:
minlat = lats[i]
if lats[i] > maxlat:
maxlat = lats[i]
lons[i] = float(fields[1])
if lons[i] < minlon:
minlon = lons[i]
if lons[i] > maxlon:
maxlon = lons[i]
timevar[:] = times
latvar[:] = lats
lonvar[:] = lons
# QC flags for dimension variables. Assume all are good
timeqcvar = nc.createVariable("TIME_QC", "b", ("TIME"), \
fill_value = QC_FILL_VALUE)
assignqcvarattributes_(timeqcvar)
timeqcvar[:] = 1
positionqcvar = nc.createVariable("POSITION_QC", "b", ("POSITION"), \
fill_value = QC_FILL_VALUE)
assignqcvarattributes_(positionqcvar)
positionqcvar[:] = 1
# Now we create the data variables
depthvar = nc.createVariable("DEPH", "f", ("TIME", "DEPTH"), \
fill_value = -99999.0)
depthvar.long_name = "Depth"
depthvar.standard_name = "depth"
depthvar.units = "m"
depthvar.positive = "down"
depthvar.valid_min = -12000.0
depthvar.valid_max = 12000.0
depthvar.axis = "Z"
depthvar.reference = "sea_level"
depthvar.coordinate_reference_frame = "urn:ogc:crs:EPSG::5113"
depthqcvar = nc.createVariable("DEPH_QC", "b", ("TIME", "DEPTH"), \
fill_value = QC_FILL_VALUE)
assignqcvarattributes_(depthqcvar)
depthqcvar[:] = 7
positionvar = nc.createVariable("POSITIONING_SYSTEM", "c", ("TIME", "DEPTH"),\
fill_value = " ")
positionvar.longname = "Positioning system"
positionvar.flag_values = "A, G, L, N, U"
positionvar.flag_meanings = "Argos, GPS, Loran, Nominal, Unknown"
sstvar = nc.createVariable("TEMP", "f", ("TIME", "DEPTH"), \
fill_value = -9999)
sstvar.long_name = "Sea temperature"
sstvar.standard_name = "sea_water_temperature"
sstvar.units = "degrees_C"
# SST is not explicitly QCed with a flag, so set to Unknown.
# Once we have per-sensor QC flags we can fill this in properly
sstqcvar = nc.createVariable("TEMP_QC", "b", ("TIME", "DEPTH"), \
fill_value = QC_FILL_VALUE)
assignqcvarattributes_(sstqcvar)
sstqcvar[:] = 0
sssvar = nc.createVariable("PSAL", "f", ("TIME", "DEPTH"), \
fill_value = -9999)
sssvar.long_name = "Practical salinity"
sssvar.standard_name = "sea_water_practical_salinity"
sssvar.units = "0.001"
# SSS is not explicitly QCed with a flag, so set to Unknown.
# Once we have per-sensor QC flags we can fill this in properly
sssqcvar = nc.createVariable("PSAL_QC", "b", ("TIME", "DEPTH"), \
fill_value = QC_FILL_VALUE)
assignqcvarattributes_(sssqcvar)
sssqcvar[:] = 0
fco2var = nc.createVariable("FCO2", "f", ("TIME", "DEPTH"), \
fill_value = -9999)
fco2var.long_name = "fugacity_of_CO2_in_sea_water"
fco2var.standard_name = "fugacity_of_CO2"
fco2var.units = "µatm"
# We do have QC flags for the fco2
fco2qcvar = nc.createVariable("FCO2_QC", "b", ("TIME", "DEPTH"), \
fill_value="-128")
assignqcvarattributes_(fco2qcvar)
# Dimension variables for data variables
depthdmvar = nc.createVariable("DEPH_DM", "c", ("TIME", "DEPTH"), \
fill_value = " ")
assigndmvarattributes_(depthdmvar)
sstdmvar = nc.createVariable("TEMP_DM", "c", ("TIME", "DEPTH"), \
fill_value = " ")
assigndmvarattributes_(sstdmvar)
sssdmvar = nc.createVariable("PSAL_DM", "c", ("TIME", "DEPTH"), \
fill_value = " ")
assigndmvarattributes_(sssdmvar)
fco2dmvar = nc.createVariable("FCO2_DM", "c", ("TIME", "DEPTH"), \
fill_value = " ")
assigndmvarattributes_(fco2dmvar)
# And populate them
depths = np.empty([len(lines), 1])
positions = np.empty([len(lines), 1], dtype="object")
temps = np.empty([len(lines), 1])
sals = np.empty([len(lines), 1])
fco2s = np.empty([len(lines), 1])
fco2qcs = np.empty([len(lines), 1])
dms = np.empty([len(lines), 1], dtype="object")
for i in range(0, len(lines)):
fields = str.split(lines[i], ",")
depths[i, 0] = 5
positions[i, 0] = "G"
dms[i, 0] = "R"
if fields[3] == "":
temps[i, 0] = -9999
else:
temps[i, 0] = fields[3]
if fields[4] == "":
sals[i, 0] = -9999
else:
sals[i, 0] = fields[4]
if fields[5] == "":
fco2s[i, 0] = -9999
else:
fco2s[i, 0] = fields[5]
if len(fields[6]) == 0:
fco2qcs[i, 0] = -128
else:
fco2qcs[i, 0] = makeqcvalue_(int(fields[6]))
depthvar[:,:] = depths
positionvar[:,:] = positions
sstvar[:,:] = temps
sssvar[:,:] = sals
fco2var[:,:] = fco2s
fco2qcvar[:,:] = fco2qcs
depthdmvar[:,:] = dms
sstdmvar[:,:] = dms
sssdmvar[:,:] = dms
fco2dmvar[:,:] = dms
# Global attributes
nc.id = filenameroot
nc.data_type = "OceanSITES trajectory data"
nc.netcdf_version = "netCDF-4 classic model"
nc.format_version = "1.2"
nc.Conventions = "CF-1.6 OceanSITES-Manual-1.2 Copernicus-InSituTAC-SRD-1.3 "\
+ "Copernicus-InSituTAC-ParametersList-3.1.0"
nc.cdm_data_type = "Trajectory"
nc.data_mode = "R"
nc.area = "Global Ocean"
nc.geospatial_lat_min = str(minlat)
nc.geospatial_lat_max = str(maxlat)
nc.geospatial_lon_min = str(minlon)
nc.geospatial_lon_max = str(maxlon)
nc.geospatial_vertical_min = "5.00"
nc.geospatial_vertical_max = "5.00"
nc.last_latitude_observation = lats[-1]
nc.last_longitude_observation = lons[-1]
nc.last_date_observation = endtime.strftime("%Y-%m-%dT%H:%M:%SZ")
nc.time_coverage_start = starttime.strftime("%Y-%m-%dT%H:%M:%SZ")
nc.time_coverage_end = endtime.strftime("%Y-%m-%dT%H:%M:%SZ")
#datasetdate = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
#nc.date_update = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
#nc.history = datasetdate + " : Creation"
nc.update_interval = "daily"
nc.data_assembly_center = "BERGEN"
nc.institution = "University of Bergen / Geophysical Institute"
nc.institution_edmo_code = "4595"
nc.institution_references = " "
nc.contact = "*****@*****.**"
nc.title = "Global Ocean - In Situ near-real time carbon observation"
nc.author = "cmems-service"
nc.naming_authority = "Copernicus"
nc.platform_code = getplatformcallsign_(platform_code)
nc.site_code = getplatformcallsign_(platform_code)
# For buoys -> Mooring observation.
platform_category_code = getplatformcategorycode_(platform_code)
nc.platform_name = getplatformname_(platform_code)
nc.source_platform_category_code = platform_category_code
nc.source = PLATFORM_CODES[platform_category_code]
nc.quality_control_indicator = "6" # "Not used"
nc.quality_index = "0"
nc.comment = " "
nc.summary = " "
nc.reference = "http://marine.copernicus.eu/, https://www.icos-cp.eu/"
nc.citation = "These data were collected and made freely available by the " \
+ "Copernicus project and the programs that contribute to it."
nc.distribution_statement = "These data follow Copernicus standards; they " \
+ "are public and free of charge. User assumes all risk for use of data. " \
+ "User must display citation in any publication or product using data. " \
+ "User must contact PI prior to any commercial use of data."
# Write the netCDF
nc.close()
# Read the netCDF file into memory
with open(ncpath, "rb") as ncfile:
ncbytes = ncfile.read()
# Delete the temp netCDF file
os.remove(ncpath)
return [filenameroot, ncbytes]
#
# and reproject from the spherical MODICE ellipsoid to wgs84 with:
#
# In[2]:
from netCDF4 import Dataset
import json
# In[ ]:
# Assume that /projects/CHARIS is sshfs mounted on this machine, and
# that the user has write permission
fid = Dataset('~/projects/CHARIS/snow_cover/modice.v0.4/min05yr_nc/MODICE.v0.4.1test.nc', 'w', format='NETCDF4')
fid.Conventions = "CF-1.6"
fid = Dataset('/home/vagrant/measures-byu/src/prod/cetb_file/templates/cetb_global_template.nc', 'w', format='NETCDF4')
fid.Conventions = "CF-1.6"
fid.title = "MODICE mask for a minimum number of years"
fid.product_version = "v0.4"
#fid.software_version_id = "TBD"
#fid.software_repository = "[email protected]:nsidc/measures-byu.git"
fid.source = "MODICE"
fid.source_version_id = "v04"
fid.history = ""
fid.comment = "Mask locations with 2 indicate MODICE for >= min_years."
fid.references = "Painter, T. H., Brodzik, M. J., A. Racoviteanu, R. Armstrong. 2012. Automated mapping of Earth's annual minimum exposed snow and ice with MODIS. Geophysical Research Letters, 39(20):L20501, doi:10.1029/2012GL053340."
fid.summary = ["An improved, enhanced-resolution, gridded passive microwave Earth System Data Record \n",
"for monitoring cryospheric and hydrologic time series\n" ]fid.title = "MEaSUREs Calibrated Passive Microwave Daily EASE-Grid 2.0 Brightness Temperature ESDR"
fid.institution = ["National Snow and Ice Data Center\n",
"Cooperative Institute for Research in Environmental Sciences\n",
def createinitfile(confM2R, ntime, var, data1=None, data2=None, data3=None, data4=None):
# Create initial file for use with ROMS. This is the same as extracting time 0 from
# the climatology file.
if (confM2R.myformat == 'NETCDF4'):
myzlib = True
else:
myzlib = False
grdROMS = confM2R.grdROMS
if not grdROMS.ioInitInitialized:
grdROMS.ioInitInitialized = True
if os.path.exists(confM2R.initname):
os.remove(confM2R.initname)
f1 = Dataset(confM2R.initname, mode='w', format=confM2R.myformat)
f1.title = "Initial forcing file (INIT) used for foring of the ROMS model"
f1.description = "Created for the %s grid file" % (confM2R.romsgridpath)
f1.grd_file = "Gridfile: %s" % (confM2R.romsgridpath)
f1.history = "Created " + time.ctime(time.time())
f1.source = "Trond Kristiansen ([email protected])"
f1.type = "File in %s format created using MODEL2ROMS" % (confM2R.myformat)
f1.link = "https://github.com/trondkr/model2roms"
f1.Conventions = "CF-1.0"
# Define dimensions
f1.createDimension('xi_rho', grdROMS.xi_rho)
f1.createDimension('eta_rho', grdROMS.eta_rho)
f1.createDimension('xi_u', grdROMS.xi_u)
f1.createDimension('eta_u', grdROMS.eta_u)
f1.createDimension('xi_v', grdROMS.xi_v)
f1.createDimension('eta_v', grdROMS.eta_v)
f1.createDimension('xi_psi', grdROMS.xi_psi)
f1.createDimension('eta_psi', grdROMS.eta_psi)
f1.createDimension('ocean_time', None)
f1.createDimension('s_rho', len(grdROMS.s_rho))
f1.createDimension('s_w', len(grdROMS.s_w))
vnc = f1.createVariable('lon_rho', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of RHO-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_rho
vnc = f1.createVariable('lat_rho', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of RHO-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_rho
vnc = f1.createVariable('lon_u', 'd', ('eta_u', 'xi_u',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of U-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_u
vnc = f1.createVariable('lat_u', 'd', ('eta_u', 'xi_u',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of U-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_u
vnc = f1.createVariable('lon_v', 'd', ('eta_v', 'xi_v',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of V-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_v
vnc = f1.createVariable('lat_v', 'd', ('eta_v', 'xi_v',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of V-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_v
vnc = f1.createVariable('lat_psi', 'd', ('eta_psi', 'xi_psi',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Latitude of PSI-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:, :] = grdROMS.lat_psi
vnc = f1.createVariable('lon_psi', 'd', ('eta_psi', 'xi_psi',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Longitude of PSI-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:, :] = grdROMS.lon_psi
vnc = f1.createVariable('h', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = 'Final bathymetry at RHO points'
vnc.units = 'meter'
vnc.field = "bath, scalar"
vnc[:, :] = grdROMS.h
vnc = f1.createVariable('s_rho', 'd', ('s_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate at RHO-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.positive = "up"
if grdROMS.vtransform == 2:
vnc.standard_name = "ocean_s_coordinate_g2"
vnc.formula_terms = "s: s_rho C: Cs_r eta: zeta depth: h depth_c: hc"
if grdROMS.vtransform == 1:
vnc.standard_name = "ocean_s_coordinate_g1"
vnc.formula_terms = "s: s_rho C: Cs_r eta: zeta depth: h depth_c: hc"
vnc.field = "s_rho, scalar"
vnc[:] = grdROMS.s_rho
vnc = f1.createVariable('s_w', 'd', ('s_w',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate at W-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.positive = "up"
if grdROMS.vtransform == 2:
vnc.standard_name = "ocean_s_coordinate_g2"
vnc.formula_terms = "s: s_w C: Cs_w eta: zeta depth: h depth_c: hc"
if grdROMS.vtransform == 1:
vnc.standard_name = "ocean_s_coordinate_g1"
vnc.formula_terms = "s: s_w C: Cs_w eta: zeta depth: h depth_c: hc"
vnc.field = "s_w, scalar"
vnc[:] = grdROMS.s_w
vnc = f1.createVariable('Cs_rho', 'd', ('s_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "S-coordinate stretching curves at RHO-points"
vnc.valid_min = -1.
vnc.valid_max = 0.
vnc.field = "s_rho, scalar"
vnc[:] = grdROMS.Cs_rho
vnc = f1.createVariable('hc', 'd')
vnc.long_name = "S-coordinate parameter, critical depth";
vnc.units = "meter"
vnc[:] = grdROMS.hc
vnc = f1.createVariable('z_r', 'd', ('s_rho', 'eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "Sigma layer to depth matrix";
vnc.units = "meter"
vnc[:, :, :] = grdROMS.z_r
vnc = f1.createVariable('Tcline', 'd')
vnc.long_name = "S-coordinate surface/bottom layer width";
vnc.units = "meter"
vnc[:] = grdROMS.tcline
vnc = f1.createVariable('theta_s', 'd')
vnc.long_name = "S-coordinate surface control parameter"
vnc[:] = grdROMS.theta_s
vnc = f1.createVariable('theta_b', 'd')
vnc.long_name = "S-coordinate bottom control parameter"
vnc[:] = grdROMS.theta_b
vnc = f1.createVariable('angle', 'd', ('eta_rho', 'xi_rho',), zlib=myzlib, fill_value=grdROMS.fillval)
vnc.long_name = "angle between xi axis and east"
vnc.units = "radian"
v_time = f1.createVariable('ocean_time', 'd', ('ocean_time',), zlib=myzlib, fill_value=grdROMS.fillval)
v_time.long_name = 'seconds since 1948-01-01 00:00:00'
v_time.units = 'seconds since 1948-01-01 00:00:00'
v_time.field = 'time, scalar, series'
if (confM2R.indatatype == "NORESM"):
v_time.calendar = 'noleap'
else:
v_time.calendar = 'standard'
v_temp = f1.createVariable('temp', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_temp.long_name = "potential temperature"
v_temp.units = "Celsius"
v_temp.time = "ocean_time"
#v_temp.missing_value = grdROMS.fillval
v_salt = f1.createVariable('salt', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_salt.long_name = "salinity"
v_salt.time = "ocean_time"
v_salt.field = "salinity, scalar, series"
#v_salt.missing_value = grdROMS.fillval
v_ssh = f1.createVariable('zeta', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ssh.long_name = "sea level"
v_ssh.units = "meter"
v_ssh.time = "ocean_time"
#v_ssh.missing_value = grdROMS.fillval
v_u = f1.createVariable('u', 'f', ('ocean_time', 's_rho', 'eta_u', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_u.long_name = "U-velocity, scalar, series"
v_u.units = "meter second-1"
v_u.time = "ocean_time"
#v_u.missing_value = grdROMS.fillval
v_v = f1.createVariable('v', 'f', ('ocean_time', 's_rho', 'eta_v', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_v.long_name = "V-velocity, scalar, series"
v_v.units = "meter second-1"
v_v.time = "ocean_time"
#v_v.missing_value = grdROMS.fillval
v_vbar = f1.createVariable('vbar', 'f', ('ocean_time', 'eta_v', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_vbar.long_name = "Barotropic V-velocity, scalar, series"
v_vbar.units = "meter second-1"
v_vbar.time = "ocean_time"
#v_vbar.missing_value = grdROMS.fillval
v_ubar = f1.createVariable('ubar', 'f', ('ocean_time', 'eta_u', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_ubar.long_name = "Barotropic U-velocity, scalar, series"
v_ubar.units = "meter second-1"
v_ubar.time = "ocean_time"
#v_ubar.missing_value = grdROMS.fillval
if confM2R.writebcg:
v_o3_c = f1.createVariable('O3_c', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_o3_c.long_name = "carbonate/total dissolved inorganic carbon"
v_o3_c.time = "ocean_time"
v_o3_c.units = "mmol C/m^3"
v_o3_c.field = "O3_c, scalar, series"
v_o3_ta = f1.createVariable('O3_TA', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_o3_ta.long_name = "carbonate/bioalkalinity"
v_o3_ta.time = "ocean_time"
v_o3_ta.units = "umol/kg"
v_o3_ta.field = "O3_ta, scalar, series"
v_n1_p = f1.createVariable('N1_p', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_n1_p.long_name = "phosphate/phosphorus"
v_n1_p.time = "ocean_time"
v_n1_p.units = "mmol P/m^3"
v_n1_p.field = "N1_p, scalar, series"
v_o2_o = f1.createVariable('O2_o', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_o2_o.long_name = "oxygen/oxygen"
v_o2_o.time = "ocean_time"
v_o2_o.units = "mmol O_2/m^3"
v_o2_o.field = "O2_o, scalar, series"
v_n3_n = f1.createVariable('N3_n', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_n3_n.long_name = "nitrate/nitrogen"
v_n3_n.time = "ocean_time"
v_n3_n.units = "mmol N/m^3"
v_n3_n.field = "N3_n, scalar, series"
v_n5_s = f1.createVariable('N5_s', 'f', ('ocean_time', 's_rho', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_n5_s.long_name = "silicate/silicate"
v_n5_s.time = "ocean_time"
v_n5_s.units = "mmol Si/m^3"
v_n5_s.field = "N5_s, scalar, series"
if confM2R.writeice:
ageice = f1.createVariable('ageice', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ageice.long_name = "time-averaged age of the ice"
ageice.units = "years"
ageice.time = "ocean_time"
ageice.field = "ice age, scalar, series"
# ageice.missing_value = grdROMS.fillval
uice = f1.createVariable('uice', 'f', ('ocean_time', 'eta_u', 'xi_u',), zlib=myzlib,
fill_value=grdROMS.fillval)
uice.long_name = "time-averaged u-component of ice velocity"
uice.units = "meter second-1"
uice.time = "ocean_time"
uice.field = "u-component of ice velocity, scalar, series"
# uice.missing_value = grdROMS.fillval
vice = f1.createVariable('vice', 'f', ('ocean_time', 'eta_v', 'xi_v',), zlib=myzlib,
fill_value=grdROMS.fillval)
vice.long_name = "time-averaged v-component of ice velocity"
vice.units = "meter second-1"
vice.time = "ocean_time"
vice.field = "v-component of ice velocity, scalar, series"
# vice.missing_value = grdROMS.fillval
aice = f1.createVariable('aice', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
aice.long_name = "time-averaged fraction of cell covered by ice"
aice.time = "ocean_time"
aice.field = "ice concentration, scalar, series"
#aice.missing_value = grdROMS.fillval
hice = f1.createVariable('hice', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
hice.long_name = "time-averaged average ice thickness in cell"
hice.units = "meter"
hice.time = "ocean_time"
hice.field = "ice thickness, scalar, series"
#hice.missing_value = grdROMS.fillval
snow_thick = f1.createVariable('snow_thick', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
snow_thick.long_name = "time-averaged thickness of snow cover"
snow_thick.units = "meter"
snow_thick.time = "ocean_time"
snow_thick.field = "snow thickness, scalar, series"
#snow_thick.missing_value = grdROMS.fillval
ti = f1.createVariable('ti', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
ti.long_name = "time-averaged interior ice temperature"
ti.units = "degrees Celcius"
ti.time = "ocean_time"
ti.field = "interior temperature, scalar, series"
#ti.missing_value = grdROMS.fillval
sfwat = f1.createVariable('sfwat', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sfwat.long_name = "time-averaged surface melt water thickness on ice"
sfwat.units = "meter"
sfwat.time = "ocean_time"
sfwat.field = "melt water thickness, scalar, series"
#sfwat.missing_value = grdROMS.fillval
tisrf = f1.createVariable('tisrf', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
tisrf.long_name = "time-averaged temperature of ice surface"
tisrf.units = "degrees Celcius"
tisrf.time = "ocean_time"
tisrf.field = "surface temperature, scalar, series"
#tisrf.missing_value = grdROMS.fillval
sig11 = f1.createVariable('sig11', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig11.long_name = "time-averaged internal ice stress 11 component"
sig11.units = "Newton meter-1"
sig11.time = "ocean_time"
sig11.field = "ice stress 11, scalar, series"
#sig11.missing_value = grdROMS.fillval
sig12 = f1.createVariable('sig12', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig12.long_name = "time-averaged internal ice stress 12 component"
sig12.units = "Newton meter-1"
sig12.time = "ocean_time"
sig12.field = "ice stress 12, scalar, series"
#sig12.missing_value = grdROMS.fillval
sig22 = f1.createVariable('sig22', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
sig22.long_name = "time-averaged internal ice stress 22 component"
sig22.units = "Newton meter-1"
sig22.time = "ocean_time"
sig22.field = "ice stress 22, scalar, series"
#sig22.missing_value = grdROMS.fillval
vnc = f1.createVariable('tau_iw', 'd')
vnc.long_name = "Tau_iw";
vnc.units = "unknown"
vnc = f1.createVariable('chu_iw', 'd')
vnc.long_name = "Chu_iw";
vnc.units = "unknown"
v_tomk = f1.createVariable('t0mk', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_tomk.long_name = "t0mk potential temperature"
v_tomk.units = "Celsius"
v_tomk.time = "ocean_time"
#v_tomk.missing_value = grdROMS.fillval
v_somk = f1.createVariable('s0mk', 'f', ('ocean_time', 'eta_rho', 'xi_rho',), zlib=myzlib,
fill_value=grdROMS.fillval)
v_somk.long_name = "s0mk salinity"
v_somk.time = "ocean_time"
v_somk.field = "salinity, scalar, series"
#v_somk.missing_value = grdROMS.fillval
print(("grdROMS.time: ", grdROMS.time))
if grdROMS.timeunits[0:7] == "seconds":
d = num2date(grdROMS.time, units=v_time.long_name, calendar=v_time.calendar)
else:
d = num2date(grdROMS.time * 86400.0, units=v_time.long_name, calendar=v_time.calendar)
print('\n')
print('=========================================================================')
print('Created INIT file')
print(('set inittime in grd.py for time-index to print (current=%s)' % (grdROMS.inittime)))
print(('The time stamp for ROMS .in file saved to initial file is=> %s' % (d)))
print(('DSTART = %s' % (grdROMS.time)))
print(('TIME_REF = %s' % (v_time.long_name)))
print('=========================================================================')
print('\n')
else:
f1 = Dataset(confM2R.initname, mode='a', format=confM2R.myformat)
ntime = 0
if (grdROMS.timeunits[0:7] == "seconds"):
f1.variables['ocean_time'][ntime] = grdROMS.time
else:
f1.variables['ocean_time'][ntime] = grdROMS.time * 86400.0
if var.lower() == 'temperature':
f1.variables['temp'][ntime, :, :, :] = data1
if confM2R.writeice:
f1.variables['t0mk'][ntime, :, :] = np.squeeze(data1[len(grdROMS.z_r) - 1, :, :])
if var.lower() == 'salinity':
f1.variables['salt'][ntime, :, :, :] = data1
if confM2R.writeice:
f1.variables['s0mk'][ntime, :, :] = np.squeeze(data1[len(grdROMS.z_r) - 1, :, :])
if var.lower() == 'ssh':
f1.variables['zeta'][ntime, :, :] = data1
if var in ['uvel', 'vvel', 'ubar', 'vbar']:
f1.variables['u'][ntime, :, :, :] = data1
f1.variables['v'][ntime, :, :, :] = data2
f1.variables['ubar'][ntime, :, :] = data3
f1.variables['vbar'][ntime, :, :] = data4
if confM2R.writebcg:
if var in ['O3_c','O3_TA','N1_p','N3_n','N5_s','O2_o']:
data1 = np.where(abs(data1) < 0, 0, data1)
if confM2R.indatatype=="NORESM":
if var=="O3_TA":
data1=data1*1.0e6/1025.
else:
data1=data1*1.0e3
f1.variables[var][ntime,:,:,:] = data1
if confM2R.writeice:
if var.lower() == "ageice":
data1 = np.where(abs(data1) > 120, 0, data1)
f1.variables['ageice'][ntime, :, :] = data1
if var.lower() in ['uice', 'vice']:
data1 = np.where(abs(data1) > 120, 0, data1)
f1.variables[var.lower()][ntime, :, :] = data1 / 100.
if var.lower() == 'aice':
data1 = np.where(abs(data1) > 120, 0, data1)
f1.variables['aice'][ntime, :, :] = data1 / 100.
f1.variables['sfwat'][ntime, :, :] = 0.
f1.variables['tisrf'][ntime, :, :] = 0.
f1.variables['ti'][ntime, :, :] = 0.
f1.variables['sig11'][ntime, :, :] = 0.
f1.variables['sig12'][ntime, :, :] = 0.
f1.variables['sig22'][ntime, :, :] = 0.
if confM2R.indatatype == 'GLORYS':
f1.variables['snow_thick'][ntime, :, :] = 0.
f1.variables['ageice'][ntime, :, :] = 0.
if var.lower() == 'hice':
data1 = np.where(abs(data1) > 10, 0, data1)
f1.variables['hice'][ntime, :, :] = data1
if var.lower() == 'snow_thick':
data1 = np.where(abs(data1) > 100, 0, data1)
f1.variables['snow_thick'][ntime, :, :] = data1
f1.variables['tau_iw'] = 0.015
f1.variables['chu_iw'] = 0.0012
f1.close()
lonsa[:] = lons_anal
latsa[:] = lats_anal
lonsf[:] = lons_fcst
latsf[:] = lats_fcst
conusmask[:] = conusmask_ccpa
thrnumv[:] = xc[:]
thrvalv[:] = thresh[:]
rootgrp.latcorners = [lats_anal[0,0], lats_anal[0,-1], lats_anal[-1,0], lats_anal[-1,-1]]
rootgrp.loncorners = [lons_anal[0,0], lons_anal[0,-1], lons_anal[-1,0], lons_anal[-1,-1]]
rootgrp.stream = "s4" # ????
rootgrp.title = "Reforecast V2 accum. ensemble-mean precip forecast and analyzed CDF + rank correlation"
rootgrp.Conventions = "CF-1.0" # ????
rootgrp.history = "Revised Mar 2016 by Hamill"
rootgrp.institution = \
"Reforecast from ERSL/PSD using NCEP/EMC GEFS, circa 2012"
rootgrp.platform = "Model"
rootgrp.references = "http://www.esrl.noaa.gov/psd/forecasts/reforecast2/"
# ---- open ensemble data file for each year, read in data, and augment cdf
# information for that year if the sample is within the month of interest
# or the neighboring month
rankcorr_fa = -99.99*np.ones((nja,nia),dtype=np.float)
nyears = len(range(2002,2016))
print 'nsamps = ',92*nyears
precipa = np.zeros((nja,nia),dtype=np.float)
precipf3d = np.zeros((92*nyears,njf,nif),dtype=np.float)
cmplgrp = Dataset('/Users/Bora/Desktop/REU/Bond/DDCode/03.nc','a')
time_1= cmplgrp.createDimension('time', None)
lat= cmplgrp.createDimension('latitude', 241)
lon= cmplgrp.createDimension('longitude', 480)
times= cmplgrp.createVariable('time',np.int32,('time',))
latitudes= cmplgrp.createVariable('latitude',np.float32,('latitude',))
longitudes=cmplgrp.createVariable('longitude',np.float32,('longitude',))
temp= cmplgrp.createVariable('t2m',np.short,('time','latitude','longitude',))
#crs = cmplgrp.createVariable('crs','i4')
import time
cmplgrp.history = 'Created ' + time.ctime(time.time())
cmplgrp.Conventions = 'CF-1.6'
latitudes.long_name = 'latitude'
latitudes.units = 'degrees_north'
longitudes.units = 'degrees_east'
longitudes.long_name='longitude'
times.long_name = 'time'
times.units = 'days since 2000-1-1 0:0:0'
times.calendar='noleap'
temp.long_name = '2 meter temperature averages for 20 years'
temp.units = 'K'
def createnetCDF(fieldfile):
''' Creates the netCDF file to then be opened in field2nc.
'''
ncfile = '/group_workspaces/jasmin/hiresgw/mj07/'+fieldfile+'.theta.nc'
f = Dataset(ncfile,'w')
zres = 180
latres = 768
lonres = 1024
# Create dimensions
time = f.createDimension('time',None)
z_hybrid_height = f.createDimension('z_hybrid_height',zres)
latitude = f.createDimension('latitude',latres)
longitude = f.createDimension('longitude',lonres)
bound = f.createDimension('bound',2)
# Create variables (added s on the end to differentiate between dimensions
# and variables)
times = f.createVariable('time','f4',('time',),zlib=True)
z_hybrid_heights = f.createVariable('z_hybrid_height','f4',
('z_hybrid_height',),zlib=True)
latitudes = f.createVariable('latitude','f4',('latitude',),zlib=True)
bounds_latitude = f.createVariable('bounds_latitude','f8',
('latitude','bound',),zlib=True)
longitudes = f.createVariable('longitude','f4',('longitude',),zlib=True)
bounds_longitude = f.createVariable('bounds_longitude','f8',
('longitude','bound',),zlib=True)
v = f.createVariable('theta','f4',('time','z_hybrid_height','latitude',
'longitude',),zlib=True)
# Add in attributes
f.Conventions = 'CF-1.6'
times.units = 'hours since 1991-03-01 00:00:00'
times.standard_name = 'time'
times.calendar = '360_day'
times.axis = 'T'
z_hybrid_heights.positive = 'up'
z_hybrid_heights.long_name = 'atmosphere hybrid height coordinate'
z_hybrid_heights.standard_name = 'atmosphere_hybrid_height_coordinate'
z_hybrid_heights.units = 'm'
z_hybrid_heights.axis = 'Z'
latitudes.bounds = 'bounds_latitude'
latitudes.units = 'degrees_north'
latitudes.standard_name = 'latitude'
latitudes.point_spacing = 'even'
latitudes.axis = 'Y'
longitudes.bounds = 'bounds_longitude'
longitudes.modulo = 360.
longitudes.point_spacing = 'even'
longitudes.standard_name = 'longitude'
longitudes.units = 'degrees_east'
longitudes.axis = 'X'
longitudes.topology = 'circular'
v.long_name = 'THETA'
v.standard_name = 'air_potential_temperature'
v.units = 'K'
v.missing_value = -1.073742e+09
# Add in values of lat, lon and height
f2 = cdms2.open('/group_workspaces/jasmin/hiresgw/xjanp/'+fieldfile)
var = f2.getVariables()
v2 = var[9]
z2 = f2.getVariables()[0]
zvals = z2.domain[0][0][:]
# Check the length of the latitude dimension
if v2.shape[2] == 768:
latvals = np.linspace(-90+90./768,90-90./768,768)
elif v2.shape[2] == 769:
latvals = np.linspace(-90,90,769)
else: raise ValueError('Unhandled latitude dimension')
# Check the length of the latitude dimension
if v2.shape[3] == 1024 and v2.shape[2] == 768:
lonvals = np.linspace(0,360-306./1024,1024)
elif v2.shape[3] == 1024 and v2.shape[2] == 769:
lonvals = np.linspace(360./(1024*2),360.-360./(1024*2),1024)
else: raise ValueError('Unhandled longitude dimension')
print v2.name_in_file
print v2.shape
#print v2.
latitudes[:] = latvals[:]
longitudes[:] = lonvals[:]
z_hybrid_heights[:] = zvals[:]
f2.close()
f.close()
var = 'dummy'
var_out = nc.createVariable(
var,
'f',
dimensions=(
"y",
"x"),
fill_value=-2e9)
var_out.units = "meters"
var_out.long_name = "Just A Dummy"
var_out.comment = "This is just a dummy variable for CDO."
var_out.grid_mapping = "mapping"
var_out.coordinates = "lon lat"
var_out[:] = 0.
mapping = nc.createVariable("mapping", 'c')
mapping.ellipsoid = "WGS84"
mapping.false_easting = 0.
mapping.false_northing = 0.
mapping.grid_mapping_name = "polar_stereographic"
mapping.latitude_of_projection_origin = 90.
mapping.standard_parallel = 70.
mapping.straight_vertical_longitude_from_pole = -45.
from time import asctime
historystr = 'Created ' + asctime() + '\n'
nc.history = historystr
nc.proj4 = projection
nc.Conventions = 'CF-1.5'
nc.close()
def output_sector_netcdf(self,netcdf_path,out_path,patch_radius,config):
"""
Segment patches of forecast tracks to only output data contined within a
region in the CONUS, as defined by the mapfile.
Args:
netcdf_path (str): Path to the full CONUS netcdf patch file.
out_path (str): Path to output new segmented netcdf files.
patch_radius (int): Size of the patch radius.
config (dict): Dictonary containing information about data and
ML variables
Returns:
Segmented patch netcdf files.
"""
nc_data = self.load_netcdf_data(netcdf_path,patch_radius)
if nc_data is not None:
out_filename = out_path + "{0}_{1}_{2}_model_patches.nc".format(
self.ensemble_name,
self.run_date.strftime(self.date_format),
self.member)
out_file = Dataset(out_filename, "w")
out_file.createDimension("p", np.shape(nc_data.variables['p'])[0])
out_file.createDimension("row", np.shape(nc_data.variables['row'])[0])
out_file.createDimension("col", np.shape(nc_data.variables['col'])[0])
out_file.createVariable("p", "i4", ("p",))
out_file.createVariable("row", "i4", ("row",))
out_file.createVariable("col", "i4", ("col",))
out_file.variables["p"][:] = nc_data.variables['p'][:]
out_file.variables["row"][:] = nc_data.variables['row'][:]
out_file.variables["col"][:] = nc_data.variables['col'][:]
out_file.Conventions = "CF-1.6"
out_file.title = "{0} Storm Patches for run {1} member {2}".format(self.ensemble_name,
self.run_date.strftime(self.date_format),
self.member)
out_file.object_variable = config.watershed_variable
meta_variables = ["lon", "lat", "i", "j", "x", "y", "masks"]
meta_units = ["degrees_east", "degrees_north", "", "", "m", "m", ""]
center_vars = ["time", "centroid_lon", "centroid_lat", "centroid_i", "centroid_j", "track_id", "track_step"]
center_units = ["hours since {0}".format(self.run_date.strftime("%Y-%m-%d %H:%M:%S")),
"degrees_east",
"degrees_north",
"",
"",
"",
""]
label_columns = ["Matched", "Max_Hail_Size", "Num_Matches", "Shape", "Location", "Scale"]
for m, meta_variable in enumerate(meta_variables):
if meta_variable in ["i", "j", "masks"]:
dtype = "i4"
else:
dtype = "f4"
m_var = out_file.createVariable(meta_variable, dtype, ("p", "row", "col"), complevel=1, zlib=True)
m_var.long_name = meta_variable
m_var.units = meta_units[m]
for c, center_var in enumerate(center_vars):
if center_var in ["time", "track_id", "track_step"]:
dtype = "i4"
else:
dtype = "f4"
c_var = out_file.createVariable(center_var, dtype, ("p",), zlib=True, complevel=1)
c_var.long_name = center_var
c_var.units =center_units[c]
for storm_variable in config.storm_variables:
s_var = out_file.createVariable(storm_variable + "_curr", "f4", ("p", "row", "col"), complevel=1, zlib=True)
s_var.long_name = storm_variable
s_var.units = ""
for potential_variable in config.potential_variables:
p_var = out_file.createVariable(potential_variable + "_prev", "f4", ("p", "row", "col"),
complevel=1, zlib=True)
p_var.long_name = potential_variable
p_var.units = ""
if config.train:
for label_column in label_columns:
if label_column in ["Matched", "Num_Matches"]:
dtype = "i4"
else:
dtype = "f4"
l_var = out_file.createVariable(label_column, dtype, ("p",), zlib=True, complevel=1)
l_var.long_name = label_column
l_var.units = ""
out_file.variables["time"][:] = nc_data.variables['time'][:]
for c_var in ["lon", "lat"]:
out_file.variables["centroid_" + c_var][:] = nc_data.variables['centroid_' + c_var][:]
for c_var in ["i", "j"]:
out_file.variables["centroid_" + c_var][:] = nc_data.variables["centroid_" + c_var][:]
out_file.variables["track_id"][:] = nc_data.variables['track_id'][:]
out_file.variables["track_step"][:] = nc_data.variables['track_step'][:]
for meta_var in meta_variables:
if meta_var in ["lon", "lat"]:
out_file.variables[meta_var][:] = nc_data.variables[meta_var][:]
else:
out_file.variables[meta_var][:] = nc_data.variables[meta_var][:]
for storm_variable in config.storm_variables:
out_file.variables[storm_variable + "_curr"][:] = nc_data.variables[storm_variable + '_curr'][:]
for p_variable in config.potential_variables:
out_file.variables[p_variable + "_prev"][:] = nc_data.variables[p_variable + '_prev'][:]
if config.train:
for label_column in label_columns:
try:
out_file.variables[label_column][:] = nc_data.variables[label_column][:]
except:
out_file.variables[label_column][:] = 0
out_file.close()
print("Output sector nc file " + out_filename)
else:
print('No {0} {1} netcdf file/sector data found'.format(self.member,
self.run_date.strftime("%Y%m%d")))
return
def WriteNCCF(FileName,Dates,Latitudes,Longitudes,ClimPoints,DataObject,DimObject,AttrObject,GlobAttrObject):
''' Sort out the date/times to write out and time bounds '''
''' Sort out clim bounds '''
''' Sort out lat and long bounds '''
''' Convert variables using the obtained scale_factor and add_offset: stored_var=int((var-offset)/scale) '''
''' Write to file, set up given dimensions, looping through all potential variables and their attributes, and then the provided dictionary of global attributes '''
# Sort out date/times to write out
print(Dates)
TimPoints,TimBounds = MakeDaysSince(Dates['StYr'],Dates['StMon'],Dates['EdYr'],Dates['EdMon'])
nTims = len(TimPoints)
# Sort out clim bounds - paired strings
ClimBounds = np.empty((12,2),dtype='|S10')
for mm in range(12):
ClimBounds[mm,0] = str(ClimPoints[0])+'-'+str(mm+1)+'-'+str(1)
ClimBounds[mm,1] = str(ClimPoints[1])+'-'+str(mm+1)+'-'+str(MonthDays[mm])
# Sort out LatBounds and LonBounds
LatBounds = np.empty((len(Latitudes),2),dtype='float')
LonBounds = np.empty((len(Longitudes),2),dtype='float')
LatBounds[:,0] = Latitudes - ((Latitudes[1]-Latitudes[0])/2.)
LatBounds[:,1] = Latitudes + ((Latitudes[1]-Latitudes[0])/2.)
LonBounds[:,0] = Longitudes - ((Longitudes[1]-Longitudes[0])/2.)
LonBounds[:,1] = Longitudes + ((Longitudes[1]-Longitudes[0])/2.)
#pdb.set_trace()
# No need to convert float data using given scale_factor and add_offset to integers - done within writing program (packV = (V-offset)/scale
# Not sure what this does to float precision though...
# Change mdi into an integer -999 because these are stored as integers
for vv in range(len(DataObject)):
DataObject[vv][np.where(DataObject[vv] == OLDMDI)] = MDI
# Create a new netCDF file - have tried zlib=True,least_significant_digit=3 (and 1) - no difference
ncfw=Dataset(FileName,'w',format='NETCDF4_CLASSIC') # need to try NETCDF4 and also play with compression but test this first
# Write out the global attributes
if ('description' in GlobAttrObject):
ncfw.description = GlobAttrObject['description']
#print(GlobAttrObject['description'])
if ('File_created' in GlobAttrObject):
ncfw.File_created = GlobAttrObject['File_created']
if ('Title' in GlobAttrObject):
ncfw.Title = GlobAttrObject['Title']
if ('Institution' in GlobAttrObject):
ncfw.Institution = GlobAttrObject['Institution']
if ('History' in GlobAttrObject):
ncfw.History = GlobAttrObject['History']
if ('Licence' in GlobAttrObject):
ncfw.Licence = GlobAttrObject['Licence']
if ('Project' in GlobAttrObject):
ncfw.Project = GlobAttrObject['Project']
if ('Processing_level' in GlobAttrObject):
ncfw.Processing_level = GlobAttrObject['Processing_level']
if ('Acknowledgement' in GlobAttrObject):
ncfw.Acknowledgement = GlobAttrObject['Acknowledgement']
if ('Source' in GlobAttrObject):
ncfw.Source = GlobAttrObject['Source']
if ('Comment' in GlobAttrObject):
ncfw.Comment = GlobAttrObject['Comment']
if ('References' in GlobAttrObject):
ncfw.References = GlobAttrObject['References']
if ('Creator_name' in GlobAttrObject):
ncfw.Creator_name = GlobAttrObject['Creator_name']
if ('Creator_email' in GlobAttrObject):
ncfw.Creator_email = GlobAttrObject['Creator_email']
if ('Version' in GlobAttrObject):
ncfw.Version = GlobAttrObject['Version']
if ('doi' in GlobAttrObject):
ncfw.doi = GlobAttrObject['doi']
if ('Conventions' in GlobAttrObject):
ncfw.Conventions = GlobAttrObject['Conventions']
if ('netcdf_type' in GlobAttrObject):
ncfw.netcdf_type = GlobAttrObject['netcdf_type']
# Loop through and set up the dimension names and quantities
for vv in range(len(DimObject[0])):
ncfw.createDimension(DimObject[0][vv],DimObject[1][vv])
# Go through each dimension and set up the variable and attributes for that dimension if needed
for vv in range(len(DimObject)-2): # ignore first two elements of the list but count all other dictionaries
print(DimObject[vv+2]['var_name'])
# NOt 100% sure this works in a loop with overwriting
# initiate variable with name, type and dimensions
MyVar = ncfw.createVariable(DimObject[vv+2]['var_name'],DimObject[vv+2]['var_type'],DimObject[vv+2]['var_dims'])
# Apply any other attributes
if ('standard_name' in DimObject[vv+2]):
MyVar.standard_name = DimObject[vv+2]['standard_name']
if ('long_name' in DimObject[vv+2]):
MyVar.long_name = DimObject[vv+2]['long_name']
if ('units' in DimObject[vv+2]):
MyVar.units = DimObject[vv+2]['units']
if ('axis' in DimObject[vv+2]):
MyVar.axis = DimObject[vv+2]['axis']
if ('calendar' in DimObject[vv+2]):
MyVar.calendar = DimObject[vv+2]['calendar']
if ('start_year' in DimObject[vv+2]):
MyVar.start_year = DimObject[vv+2]['start_year']
if ('end_year' in DimObject[vv+2]):
MyVar.end_year = DimObject[vv+2]['end_year']
if ('start_month' in DimObject[vv+2]):
MyVar.start_month = DimObject[vv+2]['start_month']
if ('end_month' in DimObject[vv+2]):
MyVar.end_month = DimObject[vv+2]['end_month']
if ('bounds' in DimObject[vv+2]):
MyVar.bounds = DimObject[vv+2]['bounds']
if ('climatology' in DimObject[vv+2]):
MyVar.climatology = DimObject[vv+2]['climatology']
if ('point_spacing' in DimObject[vv+2]):
MyVar.point_spacing = DimObject[vv+2]['point_spacing']
# Provide the data to the variable
if (DimObject[vv+2]['var_name'] == 'time'):
MyVar[:] = TimPoints
if (DimObject[vv+2]['var_name'] == 'bounds_time'):
MyVar[:,:] = TimBounds
if (DimObject[vv+2]['var_name'] == 'month'):
for mm in range(12):
MyVar[mm,:] = stringtoarr(MonthName[mm],10)
if (DimObject[vv+2]['var_name'] == 'climbounds'):
for mm in range(12):
MyVar[mm,0,:] = stringtoarr(ClimBounds[mm,0],10)
MyVar[mm,1,:] = stringtoarr(ClimBounds[mm,1],10)
if (DimObject[vv+2]['var_name'] == 'latitude'):
MyVar[:] = Latitudes
if (DimObject[vv+2]['var_name'] == 'bounds_lat'):
MyVar[:,:] = LatBounds
if (DimObject[vv+2]['var_name'] == 'longitude'):
MyVar[:] = Longitudes
if (DimObject[vv+2]['var_name'] == 'bounds_lon'):
MyVar[:,:] = LonBounds
# Go through each variable and set up the variable attributes
for vv in range(len(AttrObject)): # ignore first two elements of the list but count all other dictionaries
print(AttrObject[vv]['var_name'])
# NOt 100% sure this works in a loop with overwriting
# initiate variable with name, type and dimensions
MyVar = ncfw.createVariable(AttrObject[vv]['var_name'],AttrObject[vv]['var_type'],AttrObject[vv]['var_dims'],fill_value = AttrObject[vv]['_FillValue'])
# Apply any other attributes
if ('standard_name' in AttrObject[vv]):
MyVar.standard_name = AttrObject[vv]['standard_name']
if ('long_name' in AttrObject[vv]):
MyVar.long_name = AttrObject[vv]['long_name']
if ('cell_methods' in AttrObject[vv]):
MyVar.cell_methods = AttrObject[vv]['cell_methods']
if ('comment' in AttrObject[vv]):
MyVar.comment = AttrObject[vv]['comment']
if ('units' in AttrObject[vv]):
MyVar.units = AttrObject[vv]['units']
if ('axis' in AttrObject[vv]):
MyVar.axis = AttrObject[vv]['axis']
if ('add_offset' in AttrObject[vv]):
MyVar.add_offset = AttrObject[vv]['add_offset']
if ('scale_factor' in AttrObject[vv]):
MyVar.scale_factor = AttrObject[vv]['scale_factor']
if ('valid_min' in AttrObject[vv]):
MyVar.valid_min = AttrObject[vv]['valid_min']
if ('valid_max' in AttrObject[vv]):
MyVar.valid_max = AttrObject[vv]['valid_max']
if ('missing_value' in AttrObject[vv]):
MyVar.missing_value = AttrObject[vv]['missing_value']
# if ('_FillValue' in AttrObject[vv]):
# MyVar._FillValue = AttrObject[vv]['_FillValue']
if ('reference_period' in AttrObject[vv]):
MyVar.reference_period = AttrObject[vv]['reference_period']
if ('ancillary_variables' in AttrObject[vv]):
MyVar.ancillary_variables = AttrObject[vv]['ancillary_variables']
# Provide the data to the variable - depending on howmany dimensions there are
if (len(AttrObject[vv]['var_dims']) == 1):
MyVar[:] = DataObject[vv]
if (len(AttrObject[vv]['var_dims']) == 2):
MyVar[:,:] = DataObject[vv]
if (len(AttrObject[vv]['var_dims']) == 3):
MyVar[:,:,:] = DataObject[vv]
ncfw.close()
return # WriteNCCF
def modify_aims_netcdf(netcdf_file_path, channel_id_info):
""" Modify the downloaded netCDF file so it passes both CF and IMOS checker
input:
netcdf_file_path(str) : path of netcdf file to modify
channel_id_index(dict) : information from xml for the channel
"""
imos_env_path = os.path.join(os.environ.get('DATA_SERVICES_DIR'), 'lib', 'netcdf', 'imos_env')
if not os.path.isfile(imos_env_path):
logger = logging_aims()
logger.error('%s is not accessible' % imos_env_path)
close_logger(logger)
sys.exit(1)
dotenv.load_dotenv(imos_env_path)
netcdf_file_obj = Dataset(netcdf_file_path, 'a', format='NETCDF4')
netcdf_file_obj.naming_authority = 'IMOS'
# add gatts to NetCDF
netcdf_file_obj.aims_channel_id = int(channel_id_info['channel_id'])
if not (channel_id_info['metadata_uuid'] == 'Not Available'):
netcdf_file_obj.metadata_uuid = channel_id_info['metadata_uuid']
if not netcdf_file_obj.instrument_serial_number:
del(netcdf_file_obj.instrument_serial_number)
# add CF gatts, values stored in lib/netcdf/imos_env
netcdf_file_obj.Conventions = os.environ.get('CONVENTIONS')
netcdf_file_obj.data_centre_email = os.environ.get('DATA_CENTRE_EMAIL')
netcdf_file_obj.data_centre = os.environ.get('DATA_CENTRE')
netcdf_file_obj.project = os.environ.get('PROJECT')
netcdf_file_obj.acknowledgement = os.environ.get('ACKNOWLEDGEMENT')
netcdf_file_obj.distribution_statement = os.environ.get('DISTRIBUTION_STATEMENT')
netcdf_file_obj.date_created = strftime("%Y-%m-%dT%H:%M:%SZ", gmtime())
netcdf_file_obj.quality_control_set = 1
imos_qc_convention = 'IMOS standard set using the IODE flags'
netcdf_file_obj.author = 'laurent besnard'
netcdf_file_obj.author_email = '*****@*****.**'
rename_netcdf_attribute(netcdf_file_obj, 'geospatial_LAT_max', 'geospatial_lat_max')
rename_netcdf_attribute(netcdf_file_obj, 'geospatial_LAT_min', 'geospatial_lat_min')
rename_netcdf_attribute(netcdf_file_obj, 'geospatial_LON_max', 'geospatial_lon_max')
rename_netcdf_attribute(netcdf_file_obj, 'geospatial_LON_min', 'geospatial_lon_min')
# variables modifications
time = netcdf_file_obj.variables['time']
time.calendar = 'gregorian'
time.axis = 'T'
time.valid_min = 0.0
time.valid_max = 9999999999.0
netcdf_file_obj.renameDimension('time', 'TIME')
netcdf_file_obj.renameVariable('time', 'TIME')
netcdf_file_obj.time_coverage_start = num2date(time[:], time.units, time.calendar).min().strftime('%Y-%m-%dT%H:%M:%SZ')
netcdf_file_obj.time_coverage_end = num2date(time[:], time.units, time.calendar).max().strftime('%Y-%m-%dT%H:%M:%SZ')
# latitude longitude
latitude = netcdf_file_obj.variables['LATITUDE']
latitude.axis = 'Y'
latitude.valid_min = -90.0
latitude.valid_max = 90.0
latitude.reference_datum = 'geographical coordinates, WGS84 projection'
latitude.standard_name = 'latitude'
latitude.long_name = 'latitude'
longitude = netcdf_file_obj.variables['LONGITUDE']
longitude.axis = 'X'
longitude.valid_min = -180.0
longitude.valid_max = 180.0
longitude.reference_datum = 'geographical coordinates, WGS84 projection'
longitude.standard_name = 'longitude'
longitude.long_name = 'longitude'
# handle masked arrays
lon_array = longitude[:]
lat_array = latitude[:]
if type(lon_array) != numpy.ma.core.MaskedArray or len(lon_array) == 1:
netcdf_file_obj.geospatial_lon_min = min(lon_array)
netcdf_file_obj.geospatial_lon_max = max(lon_array)
else:
netcdf_file_obj.geospatial_lon_min = numpy.ma.MaskedArray.min(lon_array)
netcdf_file_obj.geospatial_lon_max = numpy.ma.MaskedArray.max(lon_array)
if type(lat_array) != numpy.ma.core.MaskedArray or len(lat_array) == 1:
netcdf_file_obj.geospatial_lat_min = min(lat_array)
netcdf_file_obj.geospatial_lat_max = max(lat_array)
else:
numpy.ma.MaskedArray.min(lat_array)
netcdf_file_obj.geospatial_lat_min = numpy.ma.MaskedArray.min(lat_array)
netcdf_file_obj.geospatial_lat_max = numpy.ma.MaskedArray.max(lat_array)
# Change variable name, standard name, longname, untis ....
if 'Seawater_Intake_Temperature' in netcdf_file_obj.variables.keys():
var = netcdf_file_obj.variables['Seawater_Intake_Temperature']
var.units = 'Celsius'
netcdf_file_obj.renameVariable('Seawater_Intake_Temperature', 'TEMP')
netcdf_file_obj.renameVariable('Seawater_Intake_Temperature_quality_control', 'TEMP_quality_control')
var.ancillary_variables = 'TEMP_quality_control'
if 'PSAL' in netcdf_file_obj.variables.keys():
netcdf_file_obj.variables['PSAL'].units = '1e-3'
if 'TURB' in netcdf_file_obj.variables.keys():
var = netcdf_file_obj.variables['TURB']
var.units = '1'
var.standard_name = 'sea_water_turbidity'
netcdf_file_obj.variables['TURB_quality_control'].standard_name = 'sea_water_turbidity status_flag'
if 'DOWN_PHOTOSYNTH_FLUX' in netcdf_file_obj.variables.keys():
var = netcdf_file_obj.variables['DOWN_PHOTOSYNTH_FLUX']
var.units = 'W m-2'
if 'PEAK_WAVE_DIR' in netcdf_file_obj.variables.keys():
var = netcdf_file_obj.variables['PEAK_WAVE_DIR']
var.units = 'degree'
if 'CDIR' in netcdf_file_obj.variables.keys():
var = netcdf_file_obj.variables['CDIR']
var.units = 'degree'
var.long_name = 'current_direction'
if 'CSPD' in netcdf_file_obj.variables.keys():
var = netcdf_file_obj.variables['CSPD']
var.long_name = 'current_magnitude'
if 'ALBD' in netcdf_file_obj.variables.keys():
var = netcdf_file_obj.variables['ALBD']
var.units = '1'
def clean_no_cf_variables(var, netcdf_file_obj):
"""
remove standard name of main variable and of its ancillary qc var if exists
"""
if var in netcdf_file_obj.variables.keys():
if hasattr(netcdf_file_obj.variables[var], 'standard_name'):
del netcdf_file_obj.variables[var]. standard_name
var_qc = '%s_quality_control' % var
if var_qc in netcdf_file_obj.variables.keys():
if hasattr(netcdf_file_obj.variables[var_qc], 'standard_name'):
del netcdf_file_obj.variables[var_qc]. standard_name
if hasattr(netcdf_file_obj.variables[var], 'ancillary_variables'):
netcdf_file_obj.variables[var].ancillary_variables = var_qc
if 'Dissolved_Oxygen_Percent' in netcdf_file_obj.variables.keys():
clean_no_cf_variables('Dissolved_Oxygen_Percent', netcdf_file_obj)
if 'ErrorVelocity' in netcdf_file_obj.variables.keys():
clean_no_cf_variables('ErrorVelocity', netcdf_file_obj)
netcdf_file_obj.variables['ErrorVelocity'].long_name = 'error_velocity'
if 'Average_Compass_Heading' in netcdf_file_obj.variables.keys():
clean_no_cf_variables('Average_Compass_Heading', netcdf_file_obj)
var = netcdf_file_obj.variables['Average_Compass_Heading']
var.units = 'degree'
if 'Upwelling_longwave_radiation' in netcdf_file_obj.variables.keys():
var_str = 'Upwelling_longwave_radiation'
var_qc_str = '%s_quality_control' % var_str
var = netcdf_file_obj.variables[var_str]
var_qc = netcdf_file_obj.variables[var_qc_str]
var.units = 'W m-2'
var.standard_name = 'upwelling_longwave_flux_in_air'
var_qc.standard_name = 'upwelling_longwave_flux_in_air status_flag'
if 'Downwelling_longwave_radiation' in netcdf_file_obj.variables.keys():
var_str = 'Downwelling_longwave_radiation'
var_qc_str = '%s_quality_control' % var_str
var = netcdf_file_obj.variables[var_str]
var_qc = netcdf_file_obj.variables[var_qc_str]
var.units = 'W m-2'
var.standard_name = 'downwelling_longwave_flux_in_air'
var_qc.standard_name = 'downwelling_longwave_flux_in_air status_flag'
if 'UP_TOT_RADIATION' in netcdf_file_obj.variables.keys():
var_str = 'UP_TOT_RADIATION'
var_qc_str = '%s_quality_control' % var_str
var = netcdf_file_obj.variables[var_str]
var_qc = netcdf_file_obj.variables[var_qc_str]
var.units = 'W m-2'
var.standard_name = 'upwelling_longwave_flux_in_air'
var_qc.standard_name = 'upwelling_longwave_flux_in_air status_flag'
if 'DOWN_TOT_RADIATION' in netcdf_file_obj.variables.keys():
var_str = 'DOWN_TOT_RADIATION'
var_qc_str = '%s_quality_control' % var_str
var = netcdf_file_obj.variables[var_str]
var_qc = netcdf_file_obj.variables[var_qc_str]
var.units = 'W m-2'
var.standard_name = 'downwelling_longwave_flux_in_air'
var_qc.standard_name = 'downwelling_longwave_flux_in_air status_flag'
if 'RADIATION_DOWN_NET' in netcdf_file_obj.variables.keys():
clean_no_cf_variables('RADIATION_DOWN_NET', netcdf_file_obj)
if 'fluorescence' in netcdf_file_obj.variables.keys():
netcdf_file_obj.renameVariable('fluorescence', 'CPHL')
netcdf_file_obj.variables['CPHL'].long_name = 'mass_concentration_of_inferred_chlorophyll_from_relative_fluorescence_units_in_sea_water_concentration_of_chlorophyll_in_sea_water'
if 'fluorescence_quality_control' in netcdf_file_obj.variables.keys():
netcdf_file_obj.renameVariable('fluorescence_quality_control', 'CPHL_quality_control')
netcdf_file_obj.variables['CPHL_quality_control'].long_name = 'mass_concentration_of_inferred_chlorophyll_from_relative_fluorescence_units_in_sea_waterconcentration_of_chlorophyll_in_sea_water status_flag'
clean_no_cf_variables('CPHL', netcdf_file_obj)
if 'WDIR_10min' in netcdf_file_obj.variables.keys():
netcdf_file_obj.variables['WDIR_10min'].units = 'degree'
if 'WDIR_30min' in netcdf_file_obj.variables.keys():
netcdf_file_obj.variables['WDIR_30min'].units = 'degree'
if 'R_sigma_30min' in netcdf_file_obj.variables.keys():
netcdf_file_obj.variables['R_sigma_30min'].units = 'degree'
clean_no_cf_variables('R_sigma_30min', netcdf_file_obj)
if 'WDIR_sigma_10min' in netcdf_file_obj.variables.keys():
netcdf_file_obj.variables['WDIR_sigma_10min'].units = 'degree'
clean_no_cf_variables('WDIR_sigma_10min', netcdf_file_obj)
if 'WDIR_sigma_30min' in netcdf_file_obj.variables.keys():
netcdf_file_obj.variables['WDIR_sigma_30min'].units = 'degree'
clean_no_cf_variables('WDIR_sigma_30min', netcdf_file_obj)
if 'ATMP' in netcdf_file_obj.variables.keys():
netcdf_file_obj.variables['ATMP'].units = 'hPa'
if 'RAIN_DURATION' in netcdf_file_obj.variables.keys():
clean_no_cf_variables('RAIN_DURATION', netcdf_file_obj)
if 'HAIL_DURATION' in netcdf_file_obj.variables.keys():
clean_no_cf_variables('HAIL_DURATION', netcdf_file_obj)
if 'HAIL_HIT' in netcdf_file_obj.variables.keys():
clean_no_cf_variables('HAIL_HIT', netcdf_file_obj)
netcdf_file_obj.variables['HAIL_HIT'].comment = netcdf_file_obj.variables['HAIL_HIT'].units
netcdf_file_obj.variables['HAIL_HIT'].units = '1'
if 'HAIL_INTENSITY_10min' in netcdf_file_obj.variables.keys():
clean_no_cf_variables('HAIL_INTENSITY_10min', netcdf_file_obj)
netcdf_file_obj.variables['HAIL_INTENSITY_10min'].comment = netcdf_file_obj.variables['HAIL_INTENSITY_10min'].units
netcdf_file_obj.variables['HAIL_INTENSITY_10min'].units = '1'
# add qc conventions to qc vars
variables = netcdf_file_obj.variables.keys()
qc_vars = [s for s in variables if '_quality_control' in s]
if qc_vars != []:
for var in qc_vars:
netcdf_file_obj.variables[var].quality_control_conventions = imos_qc_convention
# clean longnames, force lower case, remove space, remove double underscore
for var in variables:
if hasattr(netcdf_file_obj.variables[var], 'long_name'):
netcdf_file_obj.variables[var].long_name = netcdf_file_obj.variables[var].long_name.replace('__', '_')
netcdf_file_obj.variables[var].long_name = netcdf_file_obj.variables[var].long_name.replace(' _', '_')
netcdf_file_obj.variables[var].long_name = netcdf_file_obj.variables[var].long_name.lower()
netcdf_file_obj.close()
def tiff_to_netcdf(input_dir, output_dir, years, tempo):
# Only monthly and 8-day accepted
if tempo != 'monthly':
if tempo != '8-day':
quit('ERROR: temp variable should be either monthly or 8-day')
raster_list = sorted([os.path.join(input_dir, l) for l in os.listdir(input_dir) if l.endswith('.tif')]) # All rasters in input_dir
for year in range(len(years)):
raster_list_year = [r for r in raster_list if '.'+str(years[year]) in r] # List of rasters for the year
# Ensure number of input rasters is correct
if tempo == 'monthly' and len(raster_list_year) != 12:
quit('ERROR: There should be 12 input rasters for the year '+str(years[year]+', but there are only '+ len(raster_list_year)+'.'))
if tempo == '8-day' and len(raster_list_year) != 46:
quit('ERROR: There should be 46 input rasters for the year '+str(years[year]+', but there are only '+ len(raster_list_year)+'.'))
# Printing for visual quality control
print('Packing up these '+str(len(raster_list_year))+' rasters into the .nc file for the year '+str(years[year])+':')
print("\n".join(raster_list_year))
# Create NetCDF file
if tempo == 'monthly':
out_file = os.path.join(output_dir,'GPP.VPM.v20.'+str(years[year])+'.monthly.CMG_0.05.nc')
else:
out_file = os.path.join(output_dir,'GPP.VPM.v20.'+str(years[year])+'.8-day.CMG_0.05.nc')
nco = Dataset(out_file, 'w', clobber=True, format="NETCDF4")
# Meta-data
nco.Conventions = 'CF-1.7'
nco.title = 'Vegetation Photosynthesis Model (VPM)'
nco.institution = 'Department of Microbiology and Plant Biology, University of Oklahoma, Norman, Oklahoma'
nco.source = 'http://eomf.ou.edu'
nco.references = 'Zhang, Y., Xiao, X., Wu, X., Zhou, S., Zhang, G., Qin, Y. and Dong, J., 2017. A global moderate resolution dataset of gross primary production of vegetation for 2000-2016. Scientific data, 4, p.170165.'
nco.history = """
[2020-04-10] Added units to lat and lon for CF compliance. Also set least significant digit for GPP to 3 decimal places to reduce file size.
[2020-04-08] Scale factor has been corrected to 1.
[2020-04-07] CRS now set to WGS84. netCDF files now provided on annual basis.
[2020-04-04] First creation of VPM in netCDF format.
"""
nco.comment = 'This product has been aggregated from the original 8-day, 500 m data. Please cite the references if you use this data in your project. Contact Dr. Xiangming Xiao at [email protected] with your questions.'
# Get shape, extent, coordinates from one of the input rasters
ds = gdal.Open(raster_list[0])
a = ds.ReadAsArray()
nlat, nlon = np.shape(a)
b = ds.GetGeoTransform() # bbox, interval
lon_list = np.arange(nlon)*b[1]+b[0]
lat_list = np.arange(nlat)*b[5]+b[3]
# Create dimensions, variables and attributes
nco.createDimension('lon', nlon)
nco.createDimension('lat', nlat)
nco.createDimension('time', None)
# Time
time = nco.createVariable('time', 'f8', ('time',))
time.standard_name = 'time'
time.calendar = "gregorian"
if tempo == 'monthly':
time.units = 'days since %s-01-01 00:00:00' % str(years[year])
dates = [datetime(years[year],1+n,1) for n in range(len(raster_list_year))] # list of dates
elif tempo == '8-day':
time.units = 'days since %s-01-01 00:00:00' % str(years[year])
dates = [datetime(years[year],1,1)+n*timedelta(days=8) for n in range(len(raster_list_year))] # list of dates
# Lon
lon = nco.createVariable('lon', 'f4', ('lon',))
lon.standard_name = 'longitude'
lon.units = 'degrees_east'
# Lat
lat = nco.createVariable('lat', 'f4', ('lat',))
lat.standard_name = 'latitude'
lat.units = 'degrees_north'
# CRS - These values pulled from gdalinfo after converting GeoTiffs to WGS84
crs = nco.createVariable('crs', 'i4')
crs.long_name = 'World Geodetic System 1984 (WGS84)'
crs.grid_mapping_name = 'latitude_longitude'
crs.longitude_of_prime_meridian = 0.0
crs.semi_major_axis = 6378137.0
crs.inverse_flattening = 298.257223563
crs.spatial_ref = 'GEOGCS["WGS 84",DATUM["World Geodetic System 1984",ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["unknown"],AREA["World"],BBOX[-90,-180,90,180]],ID["EPSG",4326]]'
# GPP
GPP = nco.createVariable('GPP', float, ('time', 'lat', 'lon'),
zlib=True, chunksizes=None, least_significant_digit=3, fill_value=-9999)
GPP.long_name = 'Gross Primary Production'
if tempo == 'monthly':
GPP.units = 'g C m-2 month-2'
elif tempo == '8-day':
GPP.units = 'g C m-2 day-2'
GPP.scale_factor = 1.0
GPP.add_offset = 0.0
GPP.grid_mapping = 'crs'
GPP.set_auto_maskandscale(False)
# Write lon,lat
lon[:] = lon_list
lat[:] = lat_list
# Step through each raster for the year, writing time and data to NetCDF
for i in range(len(raster_list_year)):
time[i] = date2num(dates[i],units=time.units,calendar=time.calendar) # netCDF4 function that translates datetime object into proper format for .nc
layer = gdal.Open(raster_list_year[i])
array = layer.ReadAsArray() # data
GPP[i, :, :] = array
nco.close()
print('I have created the file: %s\n' % out_file)
def createNetCDFFileUV(grdROMS, outfilename, myformat, mytype):
if (myformat=='NETCDF4'):
myzlib = True
else:
myzlib = False
if os.path.exists(outfilename):
os.remove(outfilename)
print(('Creating atmospheric forcing file for UV wind - %s'%(outfilename)))
f1 = Dataset(outfilename, mode='w', format=myformat)
f1.title="Atmospheric frocing file used by the ROMS model"
f1.description="Created for the %s grid file"%(grdROMS.grdName)
f1.grdFile="%s"%(grdROMS.grdfilename)
f1.history = 'Created ' + time.ctime(time.time())
f1.source = 'Trond Kristiansen ([email protected])'
f1.type = "File in %s format created using MODEL2ROMS"%(myformat)
f1.link = "https://github.com/trondkr/model2roms"
f1.Conventions = "CF-1.0"
""" Define dimensions """
f1.createDimension('xi_rho', grdROMS.xi_rho)
f1.createDimension('eta_rho', grdROMS.eta_rho)
f1.createDimension('wind_time', None)
vnc = f1.createVariable('lon_rho', 'd', ('eta_rho','xi_rho',),zlib=myzlib, fill_value=grdROMS.fill_value)
vnc.long_name = 'Longitude of RHO-points'
vnc.units = 'degree_east'
vnc.standard_name = 'longitude'
vnc[:,:] = grdROMS.lon_rho
vnc = f1.createVariable('lat_rho', 'd', ('eta_rho','xi_rho',),zlib=myzlib, fill_value=grdROMS.fill_value)
vnc.long_name = 'Latitude of RHO-points'
vnc.units = 'degree_north'
vnc.standard_name = 'latitude'
vnc[:,:] = grdROMS.lat_rho
v_time = f1.createVariable('wind_time', 'd', ('wind_time',),zlib=myzlib, fill_value=grdROMS.fill_value)
if mytype == "NORESM":
v_time.long_name = 'Days since 1800-01-01 00:00:00'
v_time.units = 'Days since 1800-01-01 00:00:00'
else:
v_time.long_name = 'Days since 1948-01-01 00:00:00'
v_time.units = 'Days since 1948-01-01 00:00:00'
v_time.field = 'time, scalar, series'
v_time.calendar='noleap'
v_temp_west=f1.createVariable('Vwind', 'f', ('wind_time', 'eta_rho', 'xi_rho',),zlib=myzlib, fill_value=grdROMS.fill_value)
v_temp_west.long_name = "Eta-component of wind"
v_temp_west.units = "meter second-1"
v_temp_west.field = "Vwind, scalar, series"
v_temp_west.missing_value = grdROMS.fill_value
v_temp_west.time = "wind_time"
v_temp_west=f1.createVariable('Uwind', 'f', ('wind_time', 'eta_rho', 'xi_rho',),zlib=myzlib, fill_value=grdROMS.fill_value)
v_temp_west.long_name = "Xi-component of wind"
v_temp_west.units = "meter second-1"
v_temp_west.field = "Uwind, scalar, series"
v_temp_west.missing_value = grdROMS.fill_value
v_temp_west.time = "wind_time"
f1.close()
def write_nc_(date_txt, file_name, obs, additional_gatts=None, title_="", institution_="", location_="", source_=""):
"""Writes a netCDF file with name and full path specified by 'file_name' with attributes as listed by 'obs'.
Args:
date_txt (str):
file_name (str):
obs (list):
additional_gatts (dict):
title_ (str):
institution_ (str):
location_ (str):
source_ (str):
"""
rootgrp = Dataset(file_name, mode='w', format='NETCDF4', clobber=True)
dimension_names = []
for var in obs:
if var.dim_name is not None:
if isinstance(var.dim_name, tuple):
for dname, dsize in zip(var.dim_name, var.dim_size):
if dname not in dimension_names:
print("Adding dimension {}".format(dname))
dimension_names.append(dname)
rootgrp.createDimension(dname, dsize)
elif isinstance(var.dim_name, str):
if var.dim_name not in dimension_names:
print("Adding dimension {}".format(var.dim_name))
dimension_names.append(var.dim_name)
rootgrp.createDimension(var.dim_name, var.dim_size[0])
else:
raise
print("Adding variable {}".format(var.variable_name))
ncvar = rootgrp.createVariable(var.variable_name, var.data_type, var.dim_name)
# Copy attributes
# copy_nc_attributes(var, ncvar, list(var.__dict__.keys()))
attrs = list(var.__dict__.keys())
for attr in attrs:
if attr is "extra_attributes":
if var.extra_attributes is not None:
for attr_extra, value_extra in var.extra_attributes.items():
value_extra = getattr(var, attr_extra)
if value_extra is not None:
setattr(ncvar, attr_extra, value_extra)
elif attr is not "data":
value = getattr(var, attr)
if value is not None:
setattr(ncvar, attr, value)
ncvar[:] = var.data
# global attributes:
print("Adding global attributes")
rootgrp.Conventions = 'CF-1.7'
rootgrp.title = title_
rootgrp.institution = institution_
rootgrp.location = location_
rootgrp.source = source_
rootgrp.year = int(date_txt[:4])
rootgrp.month = int(date_txt[4:6])
rootgrp.day = int(date_txt[6:8])
rootgrp.software_version = dl_toolbox_version.__version__
# rootgrp.git_version = git_version()
rootgrp.file_uuid = str(uuid.uuid4().hex)
rootgrp.references = ''
user_name = getpass.getuser()
now_time_utc = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
history_msg = "NETCDF4 file created by user {} on {} UTC.".format(user_name, now_time_utc)
rootgrp.history = history_msg
# Additional global attributes
if additional_gatts is not None:
for key_, value_ in zip(additional_gatts.keys(), additional_gatts.values()):
setattr(rootgrp, key_, value_)
rootgrp.close()
print(history_msg)
def create_nc(var):
''' Creates the NetCDF file to save the final averages
in.
'''
filedir = '/group_workspaces/jasmin/hiresgw/mj07/monthly_means/'
filename = 'xjleha.monthlymean.'+var+'.nc'
f = Dataset(filedir+filename,'w')
# Create dimensions
time = f.createDimension('time',None)
z_hybrid_height = f.createDimension('z_hybrid_height',180)
latitude = f.createDimension('latitude',325)#**#
longitude = f.createDimension('longitude',432)
bound = f.createDimension('bound',2)
# Create variables (added s on the end to differentiate between dimensions
# and variables)
times = f.createVariable('time','f4',('time',))
z_hybrid_heights = f.createVariable('z_hybrid_height','f4',
('z_hybrid_height',))
latitudes = f.createVariable('latitude','f4',('latitude',))
bounds_latitude = f.createVariable('bounds_latitude','f8',
('latitude','bound',))
longitudes = f.createVariable('longitude','f4',('longitude',))
bounds_longitude = f.createVariable('bounds_longitude','f8',
('longitude','bound',))
v = f.createVariable('v','f4',('time','z_hybrid_height','latitude',
'longitude',),zlib=True) #**#
# Add in attributes
f.Conventions = 'CF-1.6'
times.units = 'months since 1981-09-01 00:00:00'
times.standard_name = 'time'
times.calendar = '360_day'
times.axis = 'T'
z_hybrid_heights.positive = 'up'
z_hybrid_heights.long_name = 'atmosphere hybrid height coordinate'
z_hybrid_heights.standard_name = 'atmosphere_hybrid_height_coordinate'
z_hybrid_heights.units = 'm'
z_hybrid_heights.axis = 'Z'
latitudes.bounds = 'bounds_latitude'
latitudes.units = 'degrees_north'
latitudes.standard_name = 'latitude'
latitudes.point_spacing = 'even'
latitudes.axis = 'Y'
longitudes.bounds = 'bounds_longitude'
longitudes.modulo = 360.
longitudes.point_spacing = 'even'
longitudes.standard_name = 'longitude'
longitudes.units = 'degrees_east'
longitudes.axis = 'X'
longitudes.topology = 'circular'
#**#
v.lookup_source = 'defaults (cdunifpp V0.13)'
v.standard_name = 'northward_wind'
v.long_name = 'V COMPONENT OF WIND AFTER TIMESTEP'
v.units = 'm s-1'
v.missing_value = -1.073742e+09
#**#
# need to add in a bit that saves the values of time, lat and lon
f2 = Dataset('/group_workspaces/jasmin/hiresgw/mj07/xjleha.19810901.v.nc')
lat = f2.variables['latitude']
lon = f2.variables['longitude']
height = f2.variables['z_hybrid_height']
latitudes[:] = lat[:]
longitudes[:] = lon[:]
z_hybrid_heights[:] = height[:]
f.close()
f2.close()
def def_var(nc, name, units, fillvalue):
# dimension transpose is standard: "float thk(y, x)" in NetCDF file
var = nc.createVariable(name, 'f', dimensions=("y", "x"), fill_value=fillvalue)
var.units = units
return var
bed_var = def_var(nc, "topg", "m", fill_value)
bed_var.standard_name = "bedrock_altitude"
bed_var[:] = topg
thk_var = def_var(nc, "thk", "m", fill_value)
thk_var.standard_name = "land_ice_thickness"
thk_var[:] = thk
smb_var = def_var(nc, "climatic_mass_balance", "kg m-2 s-1", fill_value)
smb_var.standard_name = "land_ice_surface_specific_mass_balance_flux"
smb_var[:] = smb
artm_var = def_var(nc, "ice_surface_temp", "K", fill_value)
artm_var[:] = artm
# set global attributes
nc.Conventions = 'CF-1.4'
historysep = ' '
historystr = time.asctime() + ': ' + historysep.join(sys.argv) + '\n'
setattr(nc, 'history', historystr)
nc.close()
print(' ... PISM-bootable NetCDF file %s written' % args.o)
def createfile(filename):
''' Creates the netCDF file to then be opened in field2nc.
'''
f = Dataset(filename,'w')
zres = 180
latres = 768
lonres = 1024
# Create dimensions
time = f.createDimension('time',None)
z_hybrid_height = f.createDimension('z_hybrid_height',zres)
latitude = f.createDimension('latitude',latres)
longitude = f.createDimension('longitude',lonres)
# Create variables (added s on the end to differentiate between dimensions
# and variables)
times = f.createVariable('time','f4',('time',),zlib=True)
z_hybrid_heights = f.createVariable('z_hybrid_height','f4',
('z_hybrid_height',),zlib=True)
latitudes = f.createVariable('latitude','f4',('latitude',),zlib=True)
longitudes = f.createVariable('longitude','f4',('longitude',),zlib=True)
v = f.createVariable('T','f4',('time','z_hybrid_height','latitude',
'longitude',),zlib=True)
# Add in attributes
f.Conventions = 'CF-1.6'
times.units = 'hours since 1991-03-01 00:00:00'
times.standard_name = 'time'
times.calendar = '360_day'
times.axis = 'T'
z_hybrid_heights.positive = 'up'
z_hybrid_heights.long_name = 'atmosphere hybrid height coordinate'
z_hybrid_heights.standard_name = 'atmosphere_hybrid_height_coordinate'
z_hybrid_heights.units = 'm'
z_hybrid_heights.axis = 'Z'
latitudes.bounds = 'bounds_latitude'
latitudes.units = 'degrees_north'
latitudes.standard_name = 'latitude'
latitudes.point_spacing = 'even'
latitudes.axis = 'Y'
longitudes.bounds = 'bounds_longitude'
longitudes.modulo = 360.
longitudes.point_spacing = 'even'
longitudes.standard_name = 'longitude'
longitudes.units = 'degrees_east'
longitudes.axis = 'X'
longitudes.topology = 'circular'
v.lookup_source = 'defaults (cdunifpp V0.14pre1)'
v.standard_name = 'air_temperature'
v.long_name = 'AIR TEMPERATURE'
v.units = 'K'
v.missing_value = -1.073742e+09
# Add in values of lat, lon and height
coordsfile = '/group_workspaces/jasmin/hiresgw/mj07/xjanpa.pb19910301.theta.nc'
f2 = Dataset(coordsfile,'r')
latvals = f2.variables['latitude']
lonvals = f2.variables['longitude']
zvals = f2.variables['z_hybrid_height']
latitudes[:] = latvals[:]
longitudes[:] = lonvals[:]
z_hybrid_heights[:] = zvals[:]
f2.close()
f.close()
var_out.units = "degrees_north"
var_out.valid_range = -90.0, 90.0
var_out.standard_name = "latitude"
var_out[:] = lat
var = "dummy"
var_out = nc.createVariable(var, "f", dimensions=("y", "x"), fill_value=-9999)
var_out.units = "meters"
var_out.long_name = "Just A Dummy"
var_out.comment = "This is just a dummy variable for CDO."
var_out.grid_mapping = "mapping"
var_out.coordinates = "lon lat"
var_out[:] = 0.0
mapping = nc.createVariable("mapping", "c")
mapping.ellipsoid = "WGS84"
mapping.false_easting = 0.0
mapping.false_northing = 0.0
mapping.grid_mapping_name = "polar_stereographic"
mapping.latitude_of_projection_origin = 90.0
mapping.standard_parallel = 70.0
mapping.straight_vertical_longitude_from_pole = -45.0
from time import asctime
historystr = "Created " + asctime() + "\n"
nc.history = historystr
nc.proj4 = projection
nc.Conventions = "CF-1.5"
nc.close()
def cloneUM4(masterfile, newfile, startdate="copy", tn=24, dt=3600.0):
"""
Creates a new UM4 netCDF file based on a master file.
Convention: Climate and Forecast (CF) version 1.4
@param secs: in seconds since 1970-01-01 00:00:00
"""
print "Started cloning %s as %s" % (masterfile, newfile)
# open master file
master = Dataset(masterfile, "r")
Mdimensions = master.dimensions.keys()
# create new file
rootgrp = Dataset(newfile, "w", format="NETCDF3_CLASSIC")
# add root dimensions
rootgrp.createDimension("time", size=tn)
rootgrp.createDimension("rlon", size=default_UM4_width)
rootgrp.createDimension("rlat", size=default_UM4_height)
rootgrp.createDimension("sigma", size=1)
# add root attributes
rootgrp.Conventions = "CF-1.4"
rootgrp.institution = "Norwegian Water Resources and Energy Directorate (NVE)"
rootgrp.source = "Compiled from several +66 hour prognoses by the Norwegian Meteorological Institute (met.no)"
rootgrp.history = "%s created" % time.ctime(time.time())
rootgrp.references = "met.no"
rootgrp.comment = "Progonosis data for www.senorge.no"
# add time variable
Mtime = master.variables["time"]
# determine start date
try:
_end = date2num(iso2datetime(startdate), timeunit)
_start = _end - ((tn - 1) * dt)
except ValueError:
# if the startdate is set to "copy" use the date of the last input file
Mdate = num2date(Mtime[0], timeunit).date()
utc6 = datetime.time(06, 00, 00)
_end = date2num(datetime.datetime.combine(Mdate, utc6), timeunit)
_start = _end - ((tn - 1) * dt)
print (_end - _start) / dt
_time = rootgrp.createVariable("time", "f8", ("time",))
_time[:] = arange(_start, _end + dt, dt) # ensures that _end is included
for attr in Mtime.ncattrs():
_time.setncattr(attr, Mtime.getncattr(attr))
# add rlon variable
Mrlon = master.variables["rlon"]
_rlon = rootgrp.createVariable("rlon", "f4", ("rlon",))
_rlon[:] = Mrlon[:]
for attr in Mrlon.ncattrs():
_rlon.setncattr(attr, Mrlon.getncattr(attr))
# add rlat variable
Mrlat = master.variables["rlat"]
_rlat = rootgrp.createVariable("rlat", "f4", ("rlat",))
_rlat[:] = Mrlat[:]
for attr in Mrlat.ncattrs():
_rlat.setncattr(attr, Mrlat.getncattr(attr))
# add sigma variable
try:
Msigma = master.variables["sigma"]
_sigma = rootgrp.createVariable("sigma", "i2", ("sigma",))
_sigma[:] = Msigma[:]
for attr in Msigma.ncattrs():
_sigma.setncattr(attr, Msigma.getncattr(attr))
except KeyError:
print "No variable called 'sigma'!"
for var in master.variables.keys():
# exclude the variables referring to dimensions
if var not in Mdimensions:
exec ("M%s = master.variables['%s']" % (var, var))
exec ("print 'Cloning %s', master.variables['%s'].dimensions" % (var, var))
exec ("_%s = rootgrp.createVariable('%s', M%s.dtype, M%s.dimensions)" % (var, var, var, var))
exec ("""for attr in M%s.ncattrs():\n\t_%s.setncattr(attr, M%s.getncattr(attr))""" % (var, var, var))
rootgrp.close()
master.close()
print "Cloning completed!"
