def fetch_era_data(variable_dict):
""" Download data from ECMWF
Parameters:
-----------
param_dic : dict
A dictionary defining the download, eg:
{"class": "ei",
"dataset": "interim",
"date": '19790101/19790201/19790301',
"grid": "0.75/0.75",
"levtype": "sfc",
"param": '165.128',
"stream": "moda",
"target": 'ERA-Int_slp.mon.mean.nc',
"type": "an",
"format": "netcdf"
}
See ('https://software.ecmwf.int/wiki/display/WEBAPI/' +
'Accessing+ECMWF+data+servers+in+batch')
Returns:
--------
Downloads files to PWD.
"""
server = ECMWFDataServer()
server.retrieve(variable_dict)
def getDataECMWF(self, filename):
# create a new ECMWFServer object
server = ECMWFDataServer()
#build a dictionary that provides the MARS like information to the ECMWF servers
# start with fixed fields that are the same for all queries
self.MARSCode = {
'stream' : "oper",
'dataset' : "interim",
'param' : str(self.param),
'date' : self.start+"/to/"+self.end,
'area' : str(self.latitude_max)+"/"+str(self.longitude_min)+"/"+str(self.latitude_min)+"/"+str(self.longitude_max),
'time' : "00/12",
'grid' : str(self.resolution)+"/"+str(self.resolution),
'target' : filename,
'levtype' : str(self.levtype),
'type' : str(self.type),
'format' : "netcdf"
}
# if the filed is a forecast, then we want the 12-hour cumulated values.
if self.type is "fc":
self.MARSCode['step'] = "12"
# if the field is analysis then we want the instantaneous values
elif self.type is "an":
self.MARSCode['step'] = '0'
# if the analysed field is also on pressure levels, then define the level that we want.
if self.levtype is "pl":
self.MARSCode['levelist'] = str(self.level)
##retrieve the data
server.retrieve(self.MARSCode)
def retrieve(request):
""" Execute Mars request
Parameters
----------
request
Returns
-------
filename
"""
import os
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
if os.path.isdir(os.path.dirname(request['target'])):
os.makedirs(os.path.isdir(os.path.dirname(request['target'])))
try:
server.retrieve(request)
print "Request was successful."
print request['target']
return True
except Exception as e:
print repr(e)
return False
def get(parameter, year):
if parameter.isdigit():
try:
paramDict = {row[3]:row[1] for row in csv.reader(open('parameter_info.csv','rU'))}
paramName = paramDict[parameter]
paramID = parameter
except IOError:
print "Parameter ID not valid"
else:
try:
paramDict = {row[1]:row[3] for row in csv.reader(open('parameter_info.csv','rU'))}
paramID = paramDict[parameter]
paramName = parameter
except IOError:
print "Parameter name not valid"
param = paramID + ".128"
outputDir = os.path.expandvars('$HOME/norgay/data/sources/ERAI/3HOURLY/'+paramName+'/')
try:
os.makedirs(outputDir)
except OSError:
if not os.path.isdir(outputDir):
raise
server = ECMWFDataServer()
if year!='1979':
startDate = str(int(year)-1) + '-12-31'
else:
startDate = year + '-01-01'
if year=='2015':
endDate = year + '-06-30'
else:
endDate = year + '-12-31'
targetFile = "ERAI_{}_{}to{}.nc".format(paramName, startDate, endDate)
server.retrieve({
'stream' : "oper",
'levtype' : "sfc",
'param' : param,
'dataset' : "interim",
'step' : "03/06/09/12",
'grid' : "0.25/0.25",
'time' : "00/12",
'date' : "{}/to/{}".format(startDate, endDate),
'type' : "fc",
'class' : "ei",
'format' : "netcdf",
'target' : outputDir+targetFile
})
def API(output_folder, DownloadType, string1, string2, string3, string4, string5, string6, string7, string8, string9, string10):
import os
from ecmwfapi import ECMWFDataServer
os.chdir(output_folder)
server = ECMWFDataServer()
if DownloadType == 1 or DownloadType == 2:
server.retrieve({
'stream' : "%s" %string1,
'levtype' : "%s" %string2,
'param' : "%s" %string3,
'dataset' : "interim",
'step' : "%s" %string4,
'grid' : "%s" %string5,
'time' : "%s" %string6,
'date' : "%s" %string7,
'type' : "%s" %string8, # http://apps.ecmwf.int/codes/grib/format/mars/type/
'class' : "%s" %string9, # http://apps.ecmwf.int/codes/grib/format/mars/class/
'area' : "%s" %string10,
'format' : "netcdf",
'target' : "data_interim.nc"
})
if DownloadType == 3:
server.retrieve({
'levelist' : "1000",
'stream' : "%s" %string1,
'levtype' : "%s" %string2,
'param' : "%s" %string3,
'dataset' : "interim",
'step' : "%s" %string4,
'grid' : "%s" %string5,
'time' : "%s" %string6,
'date' : "%s" %string7,
'type' : "%s" %string8, # http://apps.ecmwf.int/codes/grib/format/mars/type/
'class' : "%s" %string9, # http://apps.ecmwf.int/codes/grib/format/mars/class/
'area' : "%s" %string10,
'format' : "netcdf",
'target' : "data_interim.nc"
})
return()
def download(year,month):
server = ECMWFDataServer()
file = "/prj/AMMA2050/ERA5/surface/ERA5_"+str(year)+"_"+str(month).zfill(2)+"_srfc.nc"
server.retrieve({
"class": "ea",
"dataset": "era5",
"date": str(year)+"-"+str(month).zfill(2)+"-01/to/"+str(year)+"-"+str(month).zfill(2)+"-31",
"expver": "1",
"grid": "0.25/0.25",
"levtype": "sfc",
"param":"59.128/60.162/61.162/62.162/63.162/71.162/72.162/78.128/79.128/79.162/80.162/81.162/82.162/83.162/84.162/86.162/89.228/129.128/134.128/137.128/151.128/159.128/164.128/165.128/166.128/167.128/168.128/172.128/186.128/187.128/188.128/231.128/232.128/235.128/246.228/247.228" ,
"step": "0",
"stream": "oper",
"time": "06:00:00/09:00:00/12:00:00/15:00:00/18:00:00/21:00:00/00:00:00/03:00:00",
"type": "an",
"area": "25/-18.5/3.5/17",
"format": "netcdf",
"target": file
})
def loop(y):
file = "/localscratch/wllf030/cornkle/ERA-I/daily_"+ str(y) + "_pl_12UTC.nc"
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": str(y)+"-01-01/to/" + str(y) + "-12-31",
"expver": "1",
"grid": "0.75/0.75",
"levtype": "pl",
"levelist": "250/350/450/550/600/650/700/750/800/850/900/925/950",
"param": "60.128/130.128/131.128/132.128/133.128/135.128/155.128/157.128",
"step": "0",
"stream": "oper",
"time": "12:00:00",
"type": "an",
"area": "22/-18/3/15",
"format": "netcdf",
"target": file
})
def download(year, month):
server = ECMWFDataServer()
file = "/prj/AMMA2050/ERA5/pressure_levels/ERA5_"+str(year)+"_"+str(month).zfill(2)+"_pl.nc"
server.retrieve({
"class": "ea",
"dataset": "era5",
"date": str(year)+"-"+str(month).zfill(2)+"-01/to/"+str(year)+"-"+str(month).zfill(2)+"-31",
"expver": "1",
"grid": "0.25/0.25",
"levtype": "pl",
"levelist": "200/250/300/350/400/450/500/550/600/650/700/750/825/850/875/900/925/950/975",
"param": "60.128/130.128/131.128/132.128/133.128/135.128/155.128/157.128",
"step": "0",
"stream": "oper",
"time": "06:00:00/09:00:00/12:00:00/15:00:00/18:00:00/21:00:00/00:00:00/03:00:00",
"type": "an",
"area": "25/-18.5/3.5/17",
"format": "netcdf",
"target": file
})
def retrieve_netcdf(Variables_available,monthlystr,namestr,location):
"""Retrieve NetCDF file"""
from chosen_variables import chosen_variables
from location import chosen_area
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": monthlystr,
"expver": "1",
"grid": "0.125/0.125",
"area": chosen_area(location),
"levtype": "sfc",
"param": chosen_variables(Variables_available),
"step": "0",
"stream": "oper",
"target": namestr,
"time": "00/06/12/18",
"type": "an",
'format' : "netcdf"
})
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": monthlystr,
"expver": "1",
"grid": "0.125/0.125",
"area": chosen_area(location),
"levtype": "sfc",
"param": chosen_variables(Variables_available),
"step": "3/6/9/12",
"stream": "oper",
"target": namestr,
"time": "00/12",
"type": "fc",
'format' : "netcdf"
})
def download_ECMWF(date,days=2):
date2 = date + datetime.timedelta(days=days-1)
datestr = '{0:04d}-{1:02d}-{2:02d}/to/{3:04d}-{4:02d}-{5:02d}'.format(
date.year,date.month,date.day,
date2.year,date2.month,date2.day)
ncstr = 'ECMWF_{0:04d}{1:02d}{2:02d}.nc'.format(
date.year,date.month,date.day)
REQ = {}
REQ['stream'] = 'oper'
REQ['levtype'] = 'pl'
REQ['param'] = 'z/u/v'
REQ['dataset'] = 'interim'
REQ['step'] = '0'
REQ['grid'] = '1/1'
REQ['time'] = '00/06/12/18'
REQ['date'] = datestr
REQ['type'] = 'an'
REQ['class'] = 'ei'
REQ['target'] = os.path.join(ECMWFdir,ncstr)
REQ['format'] = 'netcdf'
server = ECMWFDataServer()
server.retrieve(REQ)
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
#list_dates <- seq.Date(as.Date(data_i), as.Date(data_f), by = "day")
#list_dates <- format(list_dates, "%Y%m%d")
server.retrieve({
#'stream' : "oper",
'levtype' : "sfc",
'param' : "172/134/151/165/166/167/168/169/235/33/34/31/141/139/170/183/236/39/40/41/42",
'dataset' : "interim",
'step' : "0",
'grid' : "128",
'time' : "00/06/12/18",
'date' : "20100701/to/20100701",
'type' : "an",
'class' : "ei",
#'format' : "netcdf",
'target' : "ERA-Int_sfc_20100701.grib"
})
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": "2013-01-01/to/2013-01-31",
"expver": "1",
"grid": "0.125/0.125",
"levelist": "400/450/500/550/600/650/700/750/775/800/825/850/875/900/925/950/975/1000",
"levtype": "pl",
"param": "130.128",
"step": "0",
"stream": "oper",
"area": "-2/37/-4/38",
"target": "2013001_2013031__temperature.nc",
"time": "12",
"type": "an",
})
"""
created on July 23, 2014
@author: Nikola Jajcay
"""
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"stream" : "oper",
"levtype" : "pl",
"param" : "60.128/129.128/130.128/131.128/132.128/133.128/135.128/138.128/155.128/157.128/203.128", ## https://badc.nerc.ac.uk/data/ecmwf-e40/params.html
# "dataset" : "interim", ## era40, interim, era20c
"levelist" : "100/300/500/800/850/900/925/950/1000",
"step" : "0",
# "grid" : "2.5/2.5",
"time" : "12:00:00", ## daily
"date" : "2017-04-04",
# "area" : "75/-40/25/80", ## north/west/south/east
"type" : "an", ## an for analysis, fc for forecast
"class" : "od", ## e4 for era40, ei for interim
# "format" : "netcdf",
# "padding" : "0",
"target" : "output", ## filename
"expver" : 1
})
#!/usr/bin/python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
'dataset' : 'interim',
'date' : '20121101/to/20121105',
'stream' : 'oper',
'time' : '00/06/12/18',
'grid' : '0.75/0.75',
'step' : '0',
'levtype' : 'pl',
'type' : 'an',
'class' : 'ei',
'param' : '132',
'area' : '31.925/77.575/31.825/77.675',
'levelist': '500/650/775/850/925/1000',
'target' : 'vpl.grb'
})
#! /home/meteoboy4/anaconda/bin/python
from ecmwfapi import ECMWFDataServer
#Make a list containing the desired year to download and parsing the filename later
year=["1985"]
for iyear in range(29):
iyear=iyear+1
year.append(str(int(year[0])+iyear))
print(year)
server=ECMWFDataServer()
for iyear in range(len(year)):
server.retrieve({
'stream' : "oper",
'param' : "131.128",
'dataset' : "interim",
'step' : "0",
'grid' : "1.0/1.0",
'levelist' : "300",
'levtype' : "pl",
'time' : "00/06/12/18",
'date' : year[iyear]+"-01-01/to/"+year[iyear]+"-12-31",
'expver' : "1",
'type' : "an",
'class' : "ei",
'format' : "netcdf",
'target' : "/run/media/MeteoBoy4/Data/MData/ERA-Interim/1985-2014_ALEV/Daily4/U_wind_component/300hpa/"+year[iyear]+".nc"
})
#s = "19570901/19571001/19571101/19571201/"
s = ""
for y in range(1979, 2019):
for m in range(1,13):
r = "%d%02d01/" % (y, m)
s += r
#s += "20020101/20020201/20020301/20020401/20020501/20020601/20020701/20020801"
s = s[:-1]
print(s)
#exit()
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": s, #"19790101/19790201/19790301/19790401/19790501/19790601/19790701/19790801/19790901/19791001/19791101/19791201",
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "142.128/143.128", # LP and CP
"step": "0-12/24-36",
"stream": "mdfa",
"type": "fc",
"target": "ERAint_79_19_LSP_CP.nc", # name of netcdf file
#"resol": "AV", # ???????????
"format" : "netcdf",
})
# https://confluence.ecmwf.int/display/CUSF/Unit+of+Monthly+Total+Precipitation
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
import sys
str=sys.argv[1]
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": str,
"expver": "1",
"levelist": "46/to/60",
"levtype": "sfc",
"param": "134.128/167.128",
"step": "0",
"stream": "oper",
"target": "2013/"+str.replace('-','')+"_sfc.nc",
"format": "netcdf",
"time": "00/06/12/18",
"type": "an",
"area": "60/70/10/150",
"grid": "0.36/0.36",
})
from ecmwfapi import ECMWFDataServer
import xarray as xr
import numpy as np
file = "/localscratch/wllf030/cornkle/ERA-I/daily_2006-2010_12UTCpl_night.nc"
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": "2006-06-01/to/2010-09-30",
"expver": "1",
"grid": "0.75/0.75",
"levtype": "pl",
"levelist": "600/700/850/925",
"param":
"60.128/129.128/130.128/131.128/132.128/133.128/135.128/155.128/157.128",
"step": "0",
"stream": "oper",
"time": "00:00:00",
"type": "an",
"area": "22/-12/8/12",
"format": "netcdf",
"target": file
})
dataSetVar = "interim"
dateVar = "2018-01-01/to/2018-02-28"
expverVar = "1"
gridVar = gridRes + "/" + gridRes
levtypeVar = "pl"
stepVar = "0"
streamVar = "oper"
timeVar = "00:00:00"
typeVar = "an"
formatVar = "netcdf"
for param in range(0, 2):
for lvl in levelList:
targetVar = targetFolderName + "\\" + paramNameList[param] + "\\" + "ecmwf_" + gridRes + "_" + paramNameList[param] + "_" + repr(lvl) + ".nc"
server.retrieve({
"class": classVar,
"dataset": dataSetVar,
"date": dateVar,
"expver": expverVar,
"grid": gridVar,
"levelist": lvl,
"levtype": levtypeVar,
"param": paramList[param],
"step": stepVar,
"stream": streamVar,
"time": timeVar,
"type": typeVar,
"format": formatVar,
"target": targetVar
})
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "mc",
"dataset": "cams_gfas",
"date": "2015-01-01/to/2015-01-31",
"expver": "0001",
"levtype": "sfc",
"param": "81.210/87.210",
"step": "0-24",
"stream": "gfas",
"time": "00:00:00",
"type": "ga",
"target": "GFAS_2015_01_auto.nc",
"format": "netcdf",
})
'31', '29', '31', '30', '31', '30', '31', '31', '30', '31', '30', '31'
]
for year in range(2011, 2014):
for mon in range(1, 13):
# if (year<2008 and mon<10):
# continue
leap = leap_year(year)
if (leap == 1):
time = str(year) + mon_name[mon - 1] + "01" + "/to/" + str(
year) + mon_name[mon - 1] + leap_mon[mon - 1]
print time
else:
time = str(year) + mon_name[mon - 1] + "01" + "/to/" + str(
year) + mon_name[mon - 1] + ord_mon[mon - 1]
print time
target_name = "./" + "V" + "/" + "V" + str(year) + mon_name[
mon - 1] + ".grib"
print target_name
server.retrieve({
'dataset': "interim",
'levelist': "ALL",
'date': time,
'time': "ALL",
'type': "an",
'param': "V WIND COMPONENT",
'grid': "0.75/0.75",
'target': target_name,
'format': "grib",
})
'prec': ["31.228", "fc", "sfc", "0", dates, "00", "0"],
'lsmask': ["172.128", "an", "sfc", "0", "1901-01-01", "00", "0"]
}
basename = "%s_era20c_monthly_1900-2010" % (varname)
#basename = "%s_eraint_monthly_1979-2018" % (varname)
ncfile = "%s.nc" % (basename)
if os.path.exists(ncfile):
pass
else:
opts = {
"stream": "moda",
"dataset": "era20c",
#"dataset" : "interim",
"grid": "1.25/1.25",
"param": name2code[varname][0],
"type": name2code[varname][1],
"levtype": name2code[varname][2],
"levelist": name2code[varname][3],
"date": name2code[varname][4],
"time": name2code[varname][5],
"format": "netcdf",
"target": ncfile
}
server.retrieve(opts)
print("Finished download_era20c_from_ecmwf.py!")
#!/usr/bin/env python
# Surface temp 167.128
# Pressure 54.128 levtype =
# Relative humidity 157.128
# specific humidity .128
# total cloud cover .128
from ecmwfapi import ECMWFDataServer
periode = "1979-01-01/to/2018-12-31"
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"expver": "1",
"stream": "oper",
"type": "an", # use fc for forcast data
"levtype": "sfc", # surface pressure
"param": "167.128", # surface pressure
"date": periode,
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
#"step": "0", # timestep is 3 hours
"grid":
"0.75/0.75", # 0.75, 0.75 is recomended resolution for grib, 1.0/1.0 is recomended for when you dont do global.
"area": "75/-15/30/42", #Europa --> N/W/S/E lat long degrees
"format": "netcdf",
"target": "temperature_Europa_MS.nc"
#"resol":"av"
})
# use of geopotential height or geometrical height ? geometrical height is only available through Grib1 and Grib2 file formats
out_path = './'
(uid, bdate, edate, north, south, west, east) = parseargs(sys.argv)
server = ECMWFDataServer()
print "######### ERA-interim #########"
print 'Accessing wind data from ', bdate,' to ',edate,' (YYYYMMDD)'
print "################################"
server.retrieve({
'dataset' : "interim",
'date' : "%s/to/%s"%(bdate,edate),
'time' : "00/03/06/09/12/15/18/21",
'stream' : "oper",
'levtype' : "pl",
'levelist' : "all",
'type' : "an",
'class' : "ei",
'grid' : "0.25/0.25",
# http://apps.ecmwf.int/codes/grib/param-db/
# 129 geopotential m^2*s^-2 / 130 Temperature K / 131 U component of wind m*s^-1 / 132 V component of wind m*s^-1 / 135 vertical velocity Pa*s^-1 / 156 geopotential height gpm ??? ( geopotential/g) / 157 Relative humidity %
'param' : "129/130/131/132/135/156/157",
# 156 geopotential height doesn't work -> using geopotential divided by 9.80665 (http://apps.ecmwf.int/codes/grib/param-db/?id=156)
'area' : "%d/%d/%d/%d"%(north, west, south, east),
'format' : 'netcdf',
'target' : out_path+uid+"_"+bdate+"_"+edate+"_"+str(int(north))+"_"+str(int(south))+"_"+str(int(west))+"_"+str(int(east))+".nc"
})
def downloadonefile(riqi):
ts = time()
print(riqi)
return
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/u10/u10."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "165.128", #u10
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"target": filename,
})
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/v10/v10."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "166.128", #v10
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"target": filename,
})
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/2t/2t."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levelist": "1000/975/950/925/900/875/850/825/800/775/750/700/650/600/550/500/450/400/350/300/250/225/200/175/150/125/100/70",
"levtype": "sfc",
"param": "167.128", #2m气温
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"target": filename,
})
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/sst/sst."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "34.128", #sst
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"target": filename,
})
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/sp/sp."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levelist": "1000/975/950/925/900/875/850/825/800/775/750/700/650/600/550/500/450/400/350/300/250/225/200/175/150/125/100/70",
"levtype": "sfc",
"param": "134.128", #Surface pressure
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"target": filename,
})
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/mslp/mslp."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "151.128", #mslp
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"target": filename,
})
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/tcw/tcw."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "136.128", #tcw
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"target": filename,
})
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/tcwv/tcwv."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "137.128", #tcwv
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"target": filename,
})
filename="/mnt/HD/HD_a2/Public/ERA-Interim/SURF/cape/cape."+riqi+".grb"
if(os.path.isfile(filename)): #如果存在文件名则返回
print("ok",filename)
else:
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": riqi,
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "59.128", #cape
"step": "3/6/9/12",
"stream": "oper",
"time": "00:00:00/12:00:00",
"type": "fc",
"target": filename,
})
dates = getdatesformonth(month)
for d in dates:
print(d)
refyear = int(d[:4])
hdate = '/'.join([
d.replace('%i' % refyear, '%i' % i)
for i in range(refyear - 20, refyear)
])
for prefix in ('cf',
# 'pf',
):
target = '%s/%s_%s_%s.nc' % (datadir, filename, prefix, d)
if not os.path.isfile(target):
dic = basedict.copy()
for k, v in meta[filename].items():
dic[k] = v
dic['date'] = d
dic['type'] = prefix
dic['hdate'] = hdate
dic['target'] = target
if prefix == 'pf':
dic['number'] = '1/2/3/4/5/6/7/8/9/10'
print(dic)
if server is not None:
server.retrieve(dic)
# (C) Copyright 2012-2013 ECMWF.
#
# This software is licensed under the terms of the Apache Licence Version 2.0
# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
# In applying this licence, ECMWF does not waive the privileges and immunities
# granted to it by virtue of its status as an intergovernmental organisation nor
# does it submit to any jurisdiction.
#
from ecmwfapi import ECMWFDataServer
# To run this example, you need an API key
# available from https://api.ecmwf.int/v1/key/
server = ECMWFDataServer()
server.retrieve({
'stream' : "oper",
'levtype' : "sfc",
'param' : "165.128/166.128/167.128",
'dataset' : "interim",
'step' : "0",
'grid' : "0.75/0.75",
'time' : "00/06/12/18",
'date' : "2014-07-01/to/2014-07-31",
'type' : "an",
'class' : "ei",
'format' : "netcdf",
'target' : "interim_2014-07-01to2014-07-31_00061218.nc"
})
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 19 12:20:00 2020
ERA-Interim api request template
@author: Michael Tadesse
"""
import os
os.chdir('D:\\data\\era_interim\\era_interim_netcdf')
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": '1996-01-01/to/1996-12-31',
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": '34.128',
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"type": "an",
"format": "netcdf",
"target": 'era_interim_sst_1996_.nc',
})
else:
mt_start = 1
mt_end = 12
for month in range(mt_start, mt_end+1):
lastday1=calendar.monthrange(year,month)
lastday=lastday1[1]
bdate="%s%02d01"%(year,month)
edate="%s%02d%s"%(year,month,lastday)
print("######### ERA-interim #########")
print('Accessing wind data from ', bdate,' to ',edate,' (YYYYMMDD)')
print("################################")
server.retrieve({
'dataset' : "interim",
'date' : "%s/to/%s"%(bdate,edate),
'time' : "00/06/12/18",
'step' : "0",
'stream' : "oper",
'levtype' : "pl",
'levelist' : "all",
'type' : "an",
'class' : "ei",
'grid' : "0.25/0.25",
'param' : "129/131/132/156",
'area' : "%3.2f/%3.2f/%3.2f/%3.2f"%(north, west, south, east),
'format' : 'netcdf',
'target' : "%s%05d_%s_%04d.nc"%(out_path, count, calendar.month_abbr[month],year)
})
count = count + 1
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
'stream': "oper",
'levtype': "sfc",
'param': "165.128/166.128",
'dataset': "interim",
'step': "3/6/9/12",
'grid': "0.125/0.125",
'time': "00/06/12/18",
'date': "2016-01-01/to/2016-02-28",
'type': "an",
'class': "ei",
'area': "60/-84/10/-40",
'format': "netcdf",
'target': "interim_east_01.nc"
})
# THIS HAS NOT BEEN SET UP FOR THE LAMONT PC COMPUTER
# To set this up, you will need to create a new environment in conda
# Follow instructions here: https://confluence.ecmwf.int/display/WEBAPI/Accessing+ECMWF+data+servers+in+batch
# and here: https://anaconda.org/conda-forge/ecmwf-api-client
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"area": "-75/-180/-90/179.25",
"class": "ei",
"dataset": "interim",
"date": "1984-01-01/to/2018-04-30", # update date in the future
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "151.128/165.128/166.128/167.128",
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
'type': 'an',
'resol': 'av',
'format': "netcdf",
'target': "/Users/Matt_Lawhon/Documents/Internships/ANN Antarctica Project/Antarctica.nc",
})
#%%
# Download function for the 500 pressure level .nc file
# THIS HAS NOT BEEN SET UP FOR THE LAMONT PC COMPUTER
# To set this up, you will need to create a new environment in conda
file_name = [
pathto, "CMA_", variable, "_", region, "_pf_reforecast_",
str(dy), "_", month_name_list[dm - 1], ".grib"
]
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "s2",
"dataset": "s2s",
"hdate": string.join(date_range),
"date": moddate,
"origin": origen,
"expver": "prod",
"levtype": level_type,
"level": level,
"param": variable,
"step": paso,
"stream": "enfh",
"target": string.join(file_name),
"area": region_limits,
"time": "00",
"number": num,
"type": "pf",
})
string = ""
command_pf = [
"grib_to_netcdf -M -I method,type,stream,refdate -T -o ", pathto,
"CMA_", variable, "_", region, "_pf_reforecast_",
str(dy), "_", month_name_list[dm - 1], ".nc ", pathto, "CMA_",
variable, "_", region, "_pf_reforecast_",
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": "2015-01-01",
"expver": "1",
"levelist": "46/to/60",
"levtype": "sfc",
"param": "134.128/167.128",
"step": "0",
"stream": "oper",
"target": "20150101_sfc.nc",
"format": "netcdf",
"time": "00/06/12/18",
"type": "an",
"area": "75/-20/30/70",
"grid": "0.36/0.36",
})
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
import winsound
duration = 1000 # millisecond
freq = 800 # Hz
server = ECMWFDataServer()
server.retrieve({
"class": "ti",
"dataset": "tigge",
"date": "2018-05-01/to/2018-05-31",
"expver": "prod",
"grid": "0.5/0.5",
"levelist": "300/700/1000",
"levtype": "pl",
"number": "1/2",
"origin": "ecmf",
"param": "131/132",
"step": "6",
"time": "00:00:00",
"type": "pf",
"format": "netcdf",
"target": "output",
})
winsound.Beep(freq, duration)
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": "2006-06-01/to/2010-09-30",
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": "59.128/134.128/143.128/146.128/147.128/151.128/159.128/165.128/166.128/167.128/168.128/182.128/201.128/202.128/228.128/235.128/244.128",
"step": "6",
"stream": "oper",
"time": "12:00:00",
"type": "fc",
"area": "22/-12/8/12",
"format": "netcdf",
"target": "/localscratch/wllf030/cornkle/ERA-I/daily_2006-2010_12UTCsrfc_forecast.nc"
})
latmin = args.bound[2]
latmax = args.bound[0]
outfile = args.outfile[0]
syear = args.syear[0]
eyear = args.eyear[0]
grid = args.grid[0]
# load module
from ecmwfapi import ECMWFDataServer
# run
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": "%d-01-01/to/%d-12-31" % (syear, eyear),
"expver": "1",
"grid": "%f/%f" % (grid, grid),
"levelist": "600/850", # levels to download
"levtype": "pl",
"param": "129.128", # specifies the what to download (geopotential hgt)
"step": "0",
"stream": "oper",
"time": "00:00:00/06:00:00/12:00:00/18:00:00", # Time of Days
"type": "an",
"format": "netcdf", # delete this if for some reason you want GRIB...
"area":
"%f/%f/%f/%f" % (latmax, lonmin, latmin, lonmax), # NORTH/WEST/SOUTH/EAST
"target": "%s" % (outfile) # can modify the path here
})
print " python get_erai.py <country>"
print "where <country> can be;"
print " Australia"
print " USA"
sys.exit
if sys.argv[1].lower()=="australia":
erai_info["area"] = "-10/110/-45/155"
target_directory = "/mnt/OzFlux/ERAI/"
start_year = 2014
end_year = 2016
elif sys.argv[1].lower()=="usa":
erai_info["area"] = "70/229.5/30/300"
target_directory = "/mnt/AmeriFlux/ERAI/"
start_year = 1991
end_year = 2016
else:
print "Unrecognised country option entered on command line"
print "Valid country options are:"
print " australia"
print " usa"
sys.exit()
server = ECMWFDataServer()
year_list = range(start_year,end_year,1)
for year in year_list:
print " Processing year: ",str(year)
erai_info["date"] = str(year)+"-01-01/to/"+str(year+1)+"-01-01"
erai_info["target"] = target_directory+"ERAI_"+str(year)+".nc"
server.retrieve(erai_info)
end_date = "2017-08-30"
elif sys.argv[1].lower() == "usa":
erai_info["area"] = "70/229.5/30/300"
target_directory = "/home/peter/AmeriFlux/ERAI/"
start_date = "2016-01-01"
end_date = "2017-01-01"
else:
print("Unrecognised country option entered on command line")
print("Valid country options are:")
print(" australia")
print(" usa")
sys.exit()
server = ECMWFDataServer()
sd = dateutil.parser.parse(start_date)
ed = dateutil.parser.parse(end_date)
start_year = sd.year
end_year = ed.year
year_list = list(range(start_year, end_year + 1))
for year in year_list:
print(" Processing year: ", str(year))
sds = str(year) + "-01-01"
edc = datetime.datetime(year + 1, 1, 1, 0, 0, 0)
eds = edc.strftime("%Y-%m-%d")
if ed < edc:
eds = ed.strftime("%Y-%m-%d")
erai_info["date"] = sds + "/to/" + eds
#print sds+"/to/"+eds
erai_info["target"] = target_directory + "ERAI_" + str(year) + ".nc"
server.retrieve(erai_info)
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
import datetime
day = datetime.datetime.today().day
month = datetime.datetime.today().month
if day < 10:
day = "0" + str(day)
else:
day = str(day)
if month < 10:
month = "0" + str(month)
else:
month = str(month)
server = ECMWFDataServer()
server.retrieve({
"class": "e2",
"dataset": "era20c",
"date": "2010-" + month + "-" + day,
"expver": "1",
"levtype": "sfc",
"param": "15.128/134.128/137.128/167.128",
"stream": "oper",
"time": "12:00:00",
"type": "an",
"target": "mars.grib",
})
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
import sys
str=sys.argv[1]
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": str,
"expver": "1",
"levelist": "46/to/60",
"levtype": "ml",
"param": "130.128/131.128/132.128/138.128",
"step": "0",
"stream": "oper",
"target": "2006/"+str.replace('-','')+"_ml.nc",
"format": "netcdf",
"time": "00/06/12/18",
"type": "an",
"area": "75/-20/30/70",
"grid": "0.36/0.36",
})
#!/usr/bin/python
from ecmwfapi import ECMWFDataServer
import sys
server = ECMWFDataServer()
idate = sys.argv[1]
if len(idate) != 10:
raise ValueError, "get_erainterim.py idate grid"
grid = sys.argv[2]
fname = sys.argv[3]
server.retrieve({
'dataset' : "interim",
'levtype' : 'pl',
'date' : idate[:8],
'time' : idate[-2:],
'levelist': "1000/975/950/925/900/875/850/825/800/775/750/700/650/600/550/500/450/400/350/300/250/225/200/175/150/125/100/70/50/30/20/10/7/5/3/2/1",
'type' : "an",
'param' : 'z/u/v/t/q/o3/clwc/ciwc',
'grid' : '{0}/{0}'.format(grid),
'area' : "90/0/-90/360",
'target' : fname
})
start_date = start_date.replace(day=1)
while start_date < end_date:
last_day_month = start_date + timedelta(days=33)
last_day_month = last_day_month.replace(day=1)
last_day_month = last_day_month - timedelta(days=1)
yield start_date, last_day_month
start_date = last_day_month + timedelta(days=1)
server = ECMWFDataServer()
start_date = date(2015, 4, 1)
end_date = date(2018, 7, 1)
for (d0, d1) in monthly_range(start_date, end_date):
server.retrieve({
"type": "fc",
"class": "ei",
"dataset": "interim",
"date": "{0}/to/{1}".format(d0.strftime('%Y-%m-%d'), d1.strftime('%Y-%m-%d')),
"expver": "1",
"levtype": "sfc",
"area": "75/-50/15/40", # North, West, South, East. Default: global
"grid": "0.75/0.75",
"param": "228.128",
"step": "6/12",
"stream": "oper",
"time": "00:00:00/12:00:00",
"format": "netcdf",
"target": "/g/data1/fj4/ECMWF/ERAInt/precip_{0}.nc".format(d0.strftime('%Y%m')),
})
y = np.arange(1979,2018,1)
stri = ''
for yy in y:
stri = stri+"{0}0101/{0}0201/{0}0301/{0}0401/{0}0501/{0}0601/{0}0701/{0}0801/{0}0901/{0}1001/{0}1101/{0}1201/".format(yy)
stri = stri[0:-1]
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": stri,
"expver": "1",
"grid": "0.75/0.75",
"time": "00:00:00/06:00:00/12:00:00/18:00:00",
"levtype": "sfc",
"param": "81.162/134.128/137.128/164.128/165.128/166.128/167.128/168.128/207.128",
"stream": "mnth",
"type": "an",
"step" : 0,
"area": "34/-23/-42/55",
"format": "netcdf",
"target": "/localscratch/wllf030/cornkle/ERA-I/monthly/monthly_synop_1979-2017_srfc_full.nc"
})
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 19 12:20:00 2020
ERA-Interim api request template
@author: Michael Tadesse
"""
import os
os.chdir('D:\\data\\era_interim\\era_interim_netcdf')
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": '2015-01-01/to/2015-12-31',
"expver": "1",
"grid": "0.75/0.75",
"levtype": "sfc",
"param": '228.128',
"step": "3/6/9/12",
"stream": "oper",
"time": "00:00:00/12:00:00",
"type": "fc",
"format": "netcdf",
"target": 'era_interim_prcp_2015_.nc',
})
from ecmwfapi import ECMWFDataServer
import xarray as xr
import numpy as np
file = "/localscratch/wllf030/cornkle/ERA-I/daily_2004-2014_pl.nc"
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": "1983-03-01/to/2014-09-30",
"expver": "1",
"grid": "0.75/0.75",
"levtype": "pl",
"levelist": "600/650/700/850/925/950",
"param": "60.128/130.128/131.128/132.128/133.128/135.128/155.128/157.128",
"step": "0",
"stream": "oper",
"time": "12:00:00",
"type": "an",
"area": "22/-15/3/15",
"format": "netcdf",
"target": file
})
obssclimfname = starttime+'.'+endtime+'.'+obssclimfname
obsanomfname = starttime+'.'+endtime+'.'+obsanomfname
if download_data == 1:
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({"class": "ei",
"dataset": "interim",
"date": "1995-01-01/to/2017-12-31",
"expver": "1",
"grid": "1.00/1.00",
"levelist": str(plev),
"levtype": "pl",
"param": paramid,
"step": "0",
"stream": "oper",
"time": "00/06/12/18",
"type": "an",
"area": areaid,
"format": "netcdf",
"target": obsPath+'6hrly/'+obsfname})
if create_anom == 1:
import xarray as xr
import numpy as np
da = xr.open_dataarray(obsPath+'6hrly/'+obsfname)
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": "1989-01-01",
"expver": "1",
"grid": "0.25/0.25",
"levtype": "sfc",
"param": "129.128",
"step": "0",
"stream": "oper",
"target": "China.nc",
"time": "12",
"area": "60/70/10/150",
"type": "an",
"format": "netcdf",
})
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
import sys
str = sys.argv[1]
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": str,
"expver": "1",
"levelist": "46/to/60",
"levtype": "sfc",
"param": "134.128/167.128",
"step": "0",
"stream": "oper",
"target": "2015/" + str.replace('-', '') + "_sfc.nc",
"format": "netcdf",
"time": "00/06/12/18",
"type": "an",
"area": "75/-20/30/70",
"grid": "0.36/0.36",
})
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": "2015-01-01",
"expver": "1",
"levelist": "46/to/60",
"levtype": "ml",
"param": "131.128/132.128",
"step": "0",
"stream": "oper",
"target": "20150101_U_V_ml.nc",
"time": "00/06/12/18",
"type": "an",
"area": "60/70/10/150",
"format": "netcdf",
"grid": "0.36/0.36"
})
def main(argv):
try:
opts,argv = getopt.getopt(argv,":h:i:e:s:E:o:g:P:t:f:r:",['help','[outFile]','code','[shapeFile]','start','end','[tr]'])
except getopt.GetoptError:
print 'error in parameter for eraInterimDownload. type eraInterimDownload.py -help for more detail on use '
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'eraInterimDownload.py '
print ' [mandatory] : '
print ' --init <dateStart YYYY-MM-DD>'
print ' --end <dateEnd YY-MM-DD>'
print ' --shapefile <shapefile> OU -Extend < xmin,ymax,xmax,ymin>'
print ' [optional] :'
print ' --typeData < analyse , forcast> (default forcast)'
print ' --grid <EraInterim Time> (default 0.75)'
print ' --outfile <outfolder> (default /home/user/eraInterim)'
print ' --proxy <True/False> (default False)'
print ' --temporaryFile <True/False> (default False)'
print ' --result < TxtFile / RasterFile> default RasterFile'
print ''
sys.exit()
elif opt in ('-o','--outFolder'):
oFolder = arg
elif opt in ('-i','--start'):
startDate = arg
elif opt in ('-e','--end'):
endDate = arg
elif opt in ('-s','--shapefile'):
pathToShapefile = arg
elif opt in ('-E','--tr'):
extend = arg.split(',')
elif opt in ('-g','--grid'):
grid = arg
elif opt in ('-P','--proxy'):
proxy = arg
elif opt in ('-t','--typeData'):
typeData = arg
elif opt in ('-f','--temporaryFile'):
temporaryFile = arg
elif opt in ('-r','--result'):
typeOutput = arg
if len(sys.argv) < 7:
print 'eraInterimDownload.py'
print ' -i <dateStart YYYY-MM-DD> '
print ' -e <dateEnd YY-MM-DD>'
print ' -s <shapefile> '
print ' or'
print ' -E < xmin,ymax,xmax,ymin>]'
print ''
print ' [-t < analyse , forcast> (default analyse)]'
print ' [-g <size of grid in 0.125/0.25/0.5/0.75/1.125/1.5/2/2.5/3> (default0.75)]'
print ' [-o <outfolder> (default /home/user/eraInterim)]'
print ' [-P <proxy : True/False> (default False)]'
print ' [-f <temporaryFile : True/False> (default False)]'
print ' [-r <resultOutput : TxtFile/RasterFile> (default RasterFile)]'
print ''
print 'For help on interimCode -help'
sys.exit(2)
try:
oFolder
except NameError:
oFolder = os.path.expanduser('~')
oFolder = oFolder + '/eraInterim'
print "output folder not precised : downloaded eraInterim images on "+oFolder
# verification du folder/or creation if not exists
utils.checkForFolder(oFolder)
try:
startDate
except NameError:
exit ('init Date not precised')
# verification si sartDate est une date
startDate=utils.checkForDate(startDate)
try:
endDate
except NameError:
exit ('end Date not specified')
# verification si sartDate est une date
endDate=utils.checkForDate(endDate)
if (startDate>endDate):
exit('startDate could not be greater than endDate')
today=date.today()
limitDate = today - timedelta(days=31*3)
limitDate=date(limitDate.year,limitDate.month,calendar.monthrange(limitDate.year,limitDate.month)[1])
if (startDate>limitDate or endDate>limitDate ):
exit('date could not exceed 2014-12-31')
try:
pathToShapefile
except NameError:
try:
extend
except NameError:
exit ('no Area of interest have been specified. please use -shp or -tr to declare it')
if 'pathToShapefile' in locals():
extendArea=utils.convertShpToExtend(pathToShapefile)
else:
extendArea=extend
extendArea=utils.checkForExtendValidity(extendArea)
try:
typeData
except NameError:
typeData='analyse'
try:
grid
except NameError:
grid='0.75'
grid=utils.checkForGridValidity(grid)
try:
proxy
except NameError:
proxy=False
#Proxy parameteres needed
if(proxy):
login = raw_input('login proxy : ')
pwd = raw_input('password proxy : : ')
site = raw_input('site (surf.cnes.fr) : ')
os.environ["http_proxy"] = "http://%s:%s@%s:8050"%(login,pwd,site)
os.environ["https_proxy"] = "http://%s:%s@%s:8050"%(login,pwd,site)
try:
temporaryFile
except NameError:
temporaryFile=False
try:
typeOutput
except NameError:
typeOutput='RasterFile'
"""----------------------------------------"""
#Create param if first Time
if (not utils.checkForFile(os.path.expanduser('~')+'/.ecmwfapirc')):
print ('for first connexion you have to define yout key and password on ecmwf')
print ('cf https://apps.ecmwf.int/auth/login/')
print ('')
u = raw_input('user (mail) : ')
k = raw_input('keys : ')
utils.createParamFile(os.path.expanduser('~')+'/.ecmwfapirc',u,k)
delta = endDate - startDate
nbDays = delta.days + float(delta.seconds) / 86400 + 1
#--------------------------On charge les rasters
if typeData == "analyse":
time = ['00',"12","06","18"]
step = []
nbBandByDay=len(time)
else:
time = ['00',"12"]
step = [3,6,9,12]
nbBandByDay=(12*len(time))/(len(step))+1
server = ECMWFDataServer()
""" altitude de la grille EraInterim """
# Only Forcast possible
codeGeopot= [129]
GeoFile = oFolder+"/129"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codeGeopot, GeoFile,typeData)
server.retrieve(struct)
Geo = utils.convertNETCDFtoDicArray(GeoFile)
Geo = utils.convertGeoToAlt(Geo)
#un peu inutile car ne change pas ... mais bon!
Geo = utils.computeDailyMax(Geo, nbBandByDay, typeData)
""" Vitesse du vent """
codeVent= [165,166]
vent={}
ventFile=[]
for i in codeVent:
ventFile.append(oFolder+"/"+str(i)+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc')
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, [i], ventFile[-1],typeData)
server.retrieve(struct)
vent[i]=utils.convertNETCDFtoDicArray(ventFile[-1])
vent = utils.fusVentFromDict(vent,nbBandByDay)
vent=utils.computeDailyMean(vent,nbBandByDay,typeData)
""" Humidité relative """
codePressure= [134]
pressureFile = oFolder+"/134"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codePressure, pressureFile,typeData)
server.retrieve(struct)
pressure = utils.convertNETCDFtoDicArray(pressureFile)
#oulalal c'est moche
pressureMean = utils.convertPaToKgPa(pressure)
pressure = utils.convertToHectoPascal(pressure)
pressureMean = utils.computeDailyMean(pressureMean,nbBandByDay,typeData)
codeT2m= [167]
T2mFile = oFolder+"/167"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codeT2m, T2mFile,typeData)
server.retrieve(struct)
T2m = utils.convertNETCDFtoDicArray(T2mFile)
Tmean = utils.computeDailyMean(T2m, nbBandByDay, typeData)
Tmax = utils.computeDailyMax(T2m,nbBandByDay)
Tmin = utils.computeDailyMin(T2m,nbBandByDay)
T2m = utils.convertKToD(T2m)
#T2m = utils.computeDailyMean(T2m,nbBandByDay,typeData)
codeDewP= [168]
DewPFile = oFolder+"/168"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codeDewP, DewPFile,typeData)
server.retrieve(struct)
DewP = utils.convertNETCDFtoDicArray(DewPFile)
DewP = utils.convertKToD(DewP)
#DewP = utils.computeDailyMean(DewP,nbBandByDay,typeData)
humidity = utils.ComputeHumidityFromPT(pressure,T2m,DewP)
#humidity = utils.computeDailyMean(humidity,nbBandByDay,typeData)
Hmax = utils.computeDailyMax(humidity,nbBandByDay)
Hmin = utils.computeDailyMin(humidity,nbBandByDay)
Hmean = utils.computeDailyMean(humidity,nbBandByDay,typeData)
""" ONLY FORCAST FOR THESE VAR"""
typeData="forcast"
time = ['00',"12"]
step = [3,6,9,12]
nbBandByDay=(12*len(time))/(len(step))+1
""" Rayonnement global incident journalier """
# Only Forcast possiblet
codeRay= [176]
RayFile = oFolder+"/176"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codeRay, RayFile,typeData)
server.retrieve(struct)
Ray = utils.convertNETCDFtoDicArray(RayFile)
Ray = utils.computeDailyMean(Ray,nbBandByDay,typeData)
Ray = utils.convertWToMJ(Ray)
""" downward surface solar radiation """
# Only Forcast possiblet
codeRay= [169]
RayFileDownShort = oFolder+"/169"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codeRay, RayFileDownShort,typeData)
server.retrieve(struct)
RayDownShort = utils.convertNETCDFtoDicArray(RayFileDownShort)
RayDownShort = utils.computeDailyMean(RayDownShort,nbBandByDay,typeData)
RayDownShort = utils.convertWToMJ(RayDownShort)
""" downward surface thermal radiation """
# Only Forcast possiblet
codeRay= [175]
RayFileDownLong = oFolder+"/175"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codeRay, RayFileDownLong,typeData)
server.retrieve(struct)
RayDownLong = utils.convertNETCDFtoDicArray(RayFileDownLong)
RayDownLong = utils.computeDailyMean(RayDownLong,nbBandByDay,typeData)
RayDownLong = utils.convertWToMJ(RayDownLong)
""" Evaporation """
codeEvap= [182]
EvapFile = oFolder+"/182"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codeEvap, EvapFile,typeData)
server.retrieve(struct)
Evap = utils.convertNETCDFtoDicArray(EvapFile)
Evap = utils.computeDailyMean(Evap,nbBandByDay,typeData)
#Evap = utils.convertMToMm(Evap)
""" Precipitation """
#NOT NEEDED FOR ETO BUT Exported
utils.checkForTimeValidity(time)
utils.checkForStepValidity(step,typeData)
codePrecipitation= [228]
precipitationFile = oFolder+"/228"+'_'+startDate.strftime('%Y%m%d')+'_'+endDate.strftime('%Y%m%d')+'.nc'
struct=utils.create_request_sfc(startDate, endDate, time, step, grid, extendArea, codePrecipitation, precipitationFile)
server.retrieve(struct)
precipitation = utils.convertNETCDFtoDicArray(precipitationFile)
precipitation=utils.computeDailyAccumulation(precipitation,nbBandByDay,typeData)
""" Grid of latitude [0],longitude[1] in WGS84"""
geoTransform=utils.getGeoTransform(RayFile)
shape=Ray[0].shape
latlon = utils.getCentroidLatFromArray(shape,geoTransform,grid)
""" --------------------- Compute ET0---------------------- """
ET0_0={}
ET0_1={}
ET0_2={}
DoyList=[]
DateList=[]
for i in range(0,int(nbDays)):
#jour Julien
J = utils.doy(startDate,i)
dateEnCours=startDate+ timedelta(days=i)
DateList.append(dateEnCours)
DoyList.append(J)
Hmax[i] = np.where(Hmax[i]>100,100,Hmax[i])
# --- Constants ---#
#Solar constant
Gsc = 0.0820 # [MJ.m-2.min-1]
#Albedo - grass reference crop
a = 0.23
#Ratio of molecular weight of water vapor/dry air
epsilon=0.622
#Latente heat of vaporisation
Lv=2.45 # [MJ.kg-1]
# Specific heat at constant pressure
Cp= 1.013e-3; # [MJ.kg-1.°C-1]
# Stefan-Boltzmann constant [MJ.K-4.m-2.day-1]
StefBoltz=4.903e-9; #FAO
# --- Equations ---#
# Psychometric constant [kPa.°C-1]
cte_psy = (Cp*pressureMean[i])/(epsilon*Lv) # Equation 8 Chap 3 FAO
#Mean sturation vapor presure [kPa]
#es = (utils.esat(pressureMean[i],Tmax[i]) + utils.esat(pressureMean[i],Tmin[i]))/2; #Equation 12 Chap 3
es = (utils.eocalc(Tmax[i]-273.16)+utils.eocalc(Tmin[i]-273.16))/2 #Equation 12 Chap 3
# Slope of saturation vapour pressure curve at air temperature [kPa.°C-1]
delta = utils.delta_calc(Tmean[i]); # Equation 13 Chap 3
# Actual vapour pressure derived from relative humidity [kPa]
#ea = (utils.esat(pressureMean[i]/100,Tmax[i]-273.16)*(Hmax[i]/100) + utils.esat(pressureMean[i]/100,Tmin[i]-273.16)*(Hmin[i]/100))/2; # Equation 17 Chap 3
ea = (utils.eocalc(Tmax[i]-273.16)*(Hmax[i]/100)+utils.eocalc(Tmin[i]-273.16)*(Hmin[i]/100))/2
# Conversion of latitude from degrees to radians
phi = (np.pi/180)* latlon[1];
# Relative distance Earth-Sun
dr = 1 + 0.033*math.cos(2*math.pi*J/365); # Equation 23 Chap 3
# Solar declination
d = 0.4093*math.sin(2*math.pi*J/365 - 1.39); # Equation 24 Chap 3
# sunset hour angle
ws = np.arccos(-np.tan(phi)*math.tan(d)); # Equation 25 Chap 3
"""Classical calculation FAO """
# Extraterestrial radiation for daily periods
Ra = (24.*60/np.pi)*Gsc*dr*(ws*np.sin(phi)*np.sin(d) + np.cos(phi)*np.cos(d)*np.sin(ws)) # Equation 21 Chap 3
# Clear sky solar radiation [MJ.m-2.day-1]
Rso = (0.75 + 2e-5*Geo[i])*Ra; # Equation 37 Chap 3
# Net solar radiation [MJ.m-2.day-1]
Rns = (1 - a)*RayDownShort[i]; # Equation 38 Chap 3
#
f=(1.35*(np.fmin(RayDownShort[i]/Rso,1)) - 0.35);
# Net longwave radiation [MJ.m-2.day-1]
Rnl = StefBoltz*((Tmax[i]**4 + Tmin[i]**4)/2)*(0.34 - 0.14*np.sqrt(ea))*f; # Equation 39 Chap 3
# Net Radiation [MJ.m-2.day-1]
Rn =Rns - Rnl; # Equation 40 Chap 3
G = 0; # Equation 42 Chap 3
ET0_0[i] = ( 0.408*delta*( Rn-G )+ cte_psy*( 900/(Tmean[i] + 273) )*(es - ea)*vent[i] )/( delta + cte_psy*(1 + 0.34*vent[i]) ); # Equation 6 Chap 4
""" Considering product 176 = RN these equations are not needed """
Rn = Ray[i]
# Soil heat flux at daily scale
G = 0; # Equation 42 Chap 3
ET0_1[i] = ( 0.408*delta*( Rn-G )+ cte_psy*( 900/(Tmean[i] + 273) )*(es - ea)*vent[i] )/( delta + cte_psy*(1 + 0.34*vent[i]) ); # Equation 6 Chap 4
""" Considering product 176 Evaporation """
ET0_2[i] = Evap[i]
if typeOutput=='RasterFile':
#On ecrit le fichier ET0
geoTransform=utils.getGeoTransform(RayFile)
shape=Ray[0].shape
utils.writeTiffFromDicoArray(ET0_0,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/ET0.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/ET0.tif")
#On écrit le fichier Precipitation
geoTransform=utils.getGeoTransform(precipitationFile)
shape=precipitation[0].shape
utils.writeTiffFromDicoArray(precipitation,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/precipitationAcc.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/precipitationAcc.tif")
else:
#On ecrit le fichier au format Txt
proj=utils.getProj(pathToShapefile)
utils.WriteTxtFileForEachPixel(oFolder,ET0_0,ET0_1,ET0_2,DateList,DoyList,Ray,RayDownShort,RayDownLong,Tmean,Tmax,Tmin,Hmean,Hmax,Hmin,vent,precipitation,pressureMean,Geo,latlon,proj)
utils.WritePointList(oFolder,latlon,proj)
""" ------------------------------------------- """
if(temporaryFile):
#On ecrit le fichier latlon
geoTransform=utils.getGeoTransform(GeoFile)
shape=Geo[0].shape
utils.writeTiffFromDicoArray(Geo,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/altitude.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/altitude.tif")
#On ecrit le fichier latlon
geoTransform=utils.getGeoTransform(RayFile)
shape=Ray[0].shape
utils.writeTiffFromDicoArray(latlon,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/latLon.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/latLon.tif")
#On ecrit le fichier vent --> a enlever
geoTransform=utils.getGeoTransform(ventFile[-1])
shape=vent[0].shape
utils.writeTiffFromDicoArray(vent,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/ventMean.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/ventMean.tif")
#On ecrit le fichier Rhmin
geoTransform=utils.getGeoTransform(pressureFile)
shape=pressureMean[0].shape
utils.writeTiffFromDicoArray(pressureMean,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/pressureMean.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/pressureMean.tif")
#On ecrit le fichier Rhmax
geoTransform=utils.getGeoTransform(pressureFile)
shape=Hmax[0].shape
utils.writeTiffFromDicoArray(Hmax,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/humidityMax.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/humidityMax.tif")
#On ecrit le fichier Rhmin
geoTransform=utils.getGeoTransform(pressureFile)
shape=Hmin[0].shape
utils.writeTiffFromDicoArray(Hmin,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/humidityMin.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/humidityMin.tif")
#On ecrit le fichier Tmax
geoTransform=utils.getGeoTransform(T2mFile)
shape=Tmax[0].shape
utils.writeTiffFromDicoArray(Tmax,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/TemperatureMax.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/TemperatureMax.tif")
#On ecrit le fichier Tmin
geoTransform=utils.getGeoTransform(T2mFile)
shape=Tmin[0].shape
utils.writeTiffFromDicoArray(Tmin,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/TemperatureMin.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/TemperatureMin.tif")
#On ecrit le fichier Rayonnement
geoTransform=utils.getGeoTransform(RayFile)
shape=Ray[0].shape
utils.writeTiffFromDicoArray(Ray,oFolder+"/tmp.tif",shape,geoTransform)
if 'pathToShapefile' in locals():
utils.reprojRaster(oFolder+"/tmp.tif", oFolder+"/RayonnementMean.tif",shape, pathToShapefile)
os.remove(oFolder+"/tmp.tif")
else :
utils.moveFile(oFolder+"/tmp.tif", oFolder+"/RayonnementMean.tif")
#on supprime les fichier intermédiare !
os.remove(pressureFile)
os.remove(T2mFile)
os.remove(DewPFile)
os.remove(RayFile)
os.remove(GeoFile)
for i in ventFile:
os.remove(i)
os.remove(precipitationFile)
os.remove(EvapFile)
os.remove(RayFileDownLong)
os.remove(RayFileDownShort)
pathto, "BOM_", variable, "_", region, "_pf_reforecast_",
str(dy), "_", month_name_list[dm - 1], ".grib"
]
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
"class": "s2",
"dataset": "s2s",
"hdate": string.join(date_range),
"date": "2014-01-01",
"origin": "ammc",
"expver": "prod",
"levtype": level_type,
"level": level,
"param": variable,
"step": paso,
"stream": "enfh",
"target": string.join(file_name),
"grid": "1.5/1.5",
"repres": "LL",
"area": region_limits,
"time": "00",
"number": "1/to/32",
"type": "pf",
})
string = ""
command_pf = [
"grib_to_netcdf -M -I method,type,stream,refdate -T -o ", pathto,
"BOM_", variable, "_", region, "_pf_reforecast_",
str(dy), "_", month_name_list[dm - 1], ".nc ", pathto, "BOM_",
#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
import sys
str = sys.argv[1]
server = ECMWFDataServer()
server.retrieve({
"class": "ei",
"dataset": "interim",
"date": str,
"expver": "1",
"levelist": "46/to/60",
"levtype": "ml",
"param": "131.128/132.128",
"step": "0",
"stream": "oper",
"target": "2006/" + str.replace('-', '') + "_U_V_ml.nc",
"format": "netcdf",
"time": "00/06/12/18",
"type": "an",
"area": "70/-10/35/70",
"grid": "0.36/0.36",
})
def get(year, month, outdir='.'):
"""
Get the ECMWF ERA-20C FVCOM forcing data for a given year.
Gets the following variables at the surface and model levels.
Model:
ML_PARAMS=z/q/u/v/t/d/vo
LEVELS=1000/925/850/700/500/300/250/200/150/100/70/50/30/20/10
Surface:
SFC_PARAMS=sp/msl/skt/2t/10u/10v/2d/z/lsm/sst/ci/sd/stl1/stl2/stl3/stl4/swvl1/swvl2/swvl3/swvl4
Parameters
----------
year : int
Year for which to download data.
outdir : str, optional
Output directory for the files. Defaults to the current directory.
Returns
-------
files : tuple
File paths for the analysis and forecast data (in that order).
"""
server = ECMWFDataServer()
files = []
# Buffer by four days from the current month.
date = datetime.datetime(year, month, 01, 00, 00, 00)
dom = calendar.monthrange(year, month)[-1]
start_date = date - datetime.timedelta(days=4)
end_date = date + datetime.timedelta(dom + 4)
s_start = start_date.strftime('%Y-%m-%d')
s_end = end_date.strftime('%Y-%m-%d')
prefixes = ('{:04d}-{:02d}_ML.grb2', '{:04d}-{:02d}_SFC.grib')
files = (os.path.join(outdir, prefixes[0].format(year, month)),
os.path.join(outdir, prefixes[1].format(year, month)))
if not os.path.exists(files[0]):
try:
# Pressure levels data
server.retrieve({
"class": "e2",
"dataset": "era20c",
"date": "{}/to/{}".format(s_start, s_end),
"expver": "1",
"levelist": "1/2/3/5/7/10/20/30/50/70/100/125/150/175/200/225/250/300/350/400/450/500/550/600/650/700/750/775/800/825/850/875/900/925/950/975/1000",
"levtype": "pl",
"param": "129.128/130.128/131.128/132.128/133.128/138.128/155.128",
"stream": "oper",
"target": files[0],
"time": "00/03/06/09/12/15/18/21",
"type": "an",
})
except Exception:
os.remove(files[1])
if not os.path.exists(files[1]):
try:
# Surface data
server.retrieve({
"class": "e2",
"dataset": "era20c",
"date": "{}/to/{}".format(s_start, s_end),
"expver": "1",
"levtype": "sfc",
"param": "31.128/34.128/39.128/40.128/41.128/42.128/134.128/139.128/"
"141.128/151.128/165.128/166.128/167.128/168.128/170.128/"
"183.128/235.128/236.128",
"stream": "oper",
"target": files[1],
"time": "00/06/12/18",
"type": "an",
})
except Exception:
os.remove(files[1])
return files
# Run over the years
for year in years:
# Define the file name
file = file_path+'ERAinterim-EU_'+year+'.nc'
# Let's notify our terminal where we are!
print(dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')+' NOTIFY: Starting to retrieve '+file)
## The retrieval request
server.retrieve({
"expver": "1",
"stream": "oper",
"levtype": "sfc",
"param": "176.128/165.128/166.128/167.128/151.128",
"dataset": "interim",
"step": "3/6/9/12",
"grid": "0.75/0.75",
"time": "00:00:00/12:00:00",
"date": str(year)+'-01-01/to/'+str(year)+'-12-31',
"area": "80/-31/34.5/74.25",
"type": "fc",
"class": "ei",
"format": "netcdf",
"target": file
})
