def point_wind_time_fcst_according_to_3D_wind(
model='ECMWF',
output_dir=None,
t_range=[0,60],
t_gap=3,
points={'lon':[116.3833], 'lat':[39.9], 'altitude':[1351]},
initTime=None,draw_obs=True,obs_ID=54511,day_back=0,
extra_info={
'output_head_name':' ',
'output_tail_name':' ',
'point_name':' ',
'drw_thr':True,
'levels_for_interp':[1000, 950, 925, 900, 850, 800, 700, 600, 500]}
):
#+get all the directories needed
try:
dir_rqd=[utl.Cassandra_dir(data_type='high',data_source=model,var_name='HGT',lvl=''),
utl.Cassandra_dir(data_type='high',data_source=model,var_name='UGRD',lvl=''),
utl.Cassandra_dir(data_type='high',data_source=model,var_name='VGRD',lvl='')]
except KeyError:
raise ValueError('Can not find all required directories needed')
#-get all the directories needed
if(initTime == None):
initTime = get_latest_initTime(dir_rqd[0][0:-1]+'/850')
#initTime=utl.filename_day_back_model(day_back=day_back,fhour=0)[0:8]
directory=dir_rqd[0][0:-1]
fhours = np.arange(t_range[0], t_range[1], t_gap)
filenames = [initTime+'.'+str(fhour).zfill(3) for fhour in fhours]
HGT_4D=get_model_3D_grids(directory=directory,filenames=filenames,levels=extra_info['levels_for_interp'], allExists=False)
directory=dir_rqd[1][0:-1]
U_4D=get_model_3D_grids(directory=directory,filenames=filenames,levels=extra_info['levels_for_interp'], allExists=False)
directory=dir_rqd[2][0:-1]
V_4D=get_model_3D_grids(directory=directory,filenames=filenames,levels=extra_info['levels_for_interp'], allExists=False)
#obs
if(draw_obs == True):
initial_time=pd.to_datetime(str(V_4D['forecast_reference_time'].values)).replace(tzinfo=None).to_pydatetime()
sign=0
for ifhour in V_4D['forecast_period'].values:
temp=(initial_time+timedelta(hours=ifhour))
filenames_obs=temp.strftime("%Y%m%d%H")+'0000.000'
try:
obs_data=get_station_data('SURFACE/PLOT/',filename=filenames_obs)
except:
break
if(obs_data is not None):
temp=obs_data.where(obs_data['ID']==obs_ID).dropna(how='all')
if ((ifhour == V_4D['forecast_period'].values[0]) or ((ifhour > V_4D['forecast_period'].values[0]) and (sign==0))):
if(len(temp) > 0):
sta_obs_data=obs_data.where(obs_data['ID']==obs_ID).dropna(how='all').reset_index()
sign=1
else:
if(len(temp) > 0):
sta_obs_data=sta_obs_data.append(temp).reset_index()
if(obs_data is None):
break
try:
sta_obs_data
except:
draw_obs=False
delt_xy=HGT_4D['lon'].values[1]-HGT_4D['lon'].values[0]
mask = (HGT_4D['lon']<(points['lon']+2*delt_xy))&(HGT_4D['lon']>(points['lon']-2*delt_xy))&(HGT_4D['lat']<(points['lat']+2*delt_xy))&(HGT_4D['lat']>(points['lat']-2*delt_xy))
HGT_4D_sm=HGT_4D['data'].where(mask,drop=True)
U_4D_sm=U_4D['data'].where(mask,drop=True)
V_4D_sm=V_4D['data'].where(mask,drop=True)
lon_md=np.squeeze(HGT_4D_sm['lon'].values)
lat_md=np.squeeze(HGT_4D_sm['lat'].values)
alt_md=np.squeeze(HGT_4D_sm.values*10).flatten()
time_md=np.squeeze(HGT_4D_sm['forecast_period'].values)
coords = np.zeros((len(time_md),len(extra_info['levels_for_interp']),len(lat_md),len(lon_md),4))
coords[...,0]=time_md.reshape((len(time_md),1,1,1))
coords[...,2] = lat_md.reshape((1,1,len(lat_md),1))
coords[...,3] = lon_md.reshape((1,1,1,len(lon_md)))
coords = coords.reshape((alt_md.size,4))
coords[:,1]=alt_md
interpolator_U = LinearNDInterpolator(coords,U_4D_sm.values.reshape((U_4D_sm.values.size)),rescale=True)
interpolator_V = LinearNDInterpolator(coords,V_4D_sm.values.reshape((V_4D_sm.values.size)),rescale=True)
coords2 = np.zeros((len(time_md),1,1,1,4))
coords2[...,0]=time_md.reshape((len(time_md),1,1,1))
coords2[...,1]=points['altitude'][0]
coords2[...,2] = points['lat'][0]
coords2[...,3] = points['lon'][0]
coords2 = coords2.reshape((time_md.size,4))
U_interped=np.squeeze(interpolator_U(coords2))
V_interped=np.squeeze(interpolator_V(coords2))
time_info=HGT_4D_sm.coords
sta_graphics.draw_point_wind(U=U_interped,V=V_interped,
model=model,
output_dir=output_dir,
points=points,
time_info=time_info,
extra_info=extra_info
)
def point_uv_gust_tmp_rh_rn_fcst(output_dir=None,
t_range=[0, 60],
t_gap=3,
points={
'lon': [116.3833],
'lat': [39.9],
'altitude': [1351]
},
initTime=None,
day_back=0,
extra_info={
'output_head_name': ' ',
'output_tail_name': ' ',
'point_name': ' '
},
**kwargs):
#+get all the directories needed
try:
dir_rqd = [
utl.Cassandra_dir(data_type='surface',
data_source='中央气象台中短期指导',
var_name='T2m'),
utl.Cassandra_dir(data_type='surface',
data_source='中央气象台中短期指导',
var_name='u10m'),
utl.Cassandra_dir(data_type='surface',
data_source='中央气象台中短期指导',
var_name='v10m'),
utl.Cassandra_dir(data_type='surface',
data_source='中央气象台中短期指导',
var_name='rh2m'),
utl.Cassandra_dir(data_type='surface',
data_source='中央气象台中短期指导',
var_name='RAIN' + str(t_gap).zfill(2)),
utl.Cassandra_dir(data_type='surface',
data_source='OBS',
var_name='PLOT_GUST')
]
except KeyError:
raise ValueError('Can not find all required directories needed')
#-get all the directories needed
if (initTime == None):
initTime = MICAPS_IO.get_latest_initTime(dir_rqd[0])
#initTime=utl.filename_day_back_model(day_back=day_back,fhour=0)[0:8]
gust_sta = MICAPS_IO.get_station_data(directory=dir_rqd[5],
dropna=True,
cache=False)
datetime_sta = pd.to_datetime(str(
gust_sta.time[0])).replace(tzinfo=None).to_pydatetime()
datetime_model_initTime = datetime.strptime('20' + initTime, '%Y%m%d%H')
u10_his_md = []
v10_his_md = []
wsp_his_sta_point = []
model_filenames_his = None
for iinit in range(0, 240, 12):
for ifhour in range(0, 87, 3):
for iobs in range(0, 168, 1):
initTime_his = datetime_model_initTime - timedelta(hours=iinit)
validTime_his = initTime_his + timedelta(hours=ifhour)
staTime_his = datetime_sta - timedelta(hours=iobs)
if (staTime_his == validTime_his):
model_filename_his = initTime_his.strftime(
'%Y%m%d%H')[2:10] + '.' + str(ifhour).zfill(3)
sta_filename_his = validTime_his.strftime(
'%Y%m%d%H') + '0000.000'
data_md1 = MICAPS_IO.get_model_grid(
dir_rqd[1], filename=model_filename_his)
if (data_md1 is None):
continue
data_md2 = MICAPS_IO.get_model_grid(
dir_rqd[1], filename=model_filename_his)
if (data_md2 is None):
continue
data_sta = MICAPS_IO.get_station_data(
directory=dir_rqd[5],
filename=sta_filename_his,
dropna=True,
cache=True)
if (data_sta is None):
continue
u10_his_md.append(data_md1)
v10_his_md.append(data_md2)
wsp_his_sta_interp = utl.sta_to_point_interpolation(
points=points, sta=data_sta, var_name='Gust_speed')
wsp_his_sta_point.append(wsp_his_sta_interp[:])
u10_his_md = xr.concat(u10_his_md, dim='time')
v10_his_md = xr.concat(v10_his_md, dim='time')
wsp_his_md = (u10_his_md**2 + v10_his_md**2)**0.5
wsp_his_md_point = wsp_his_md.interp(lon=('points', points['lon']),
lat=('points', points['lat']))
model = LinearRegression(copy_X=True,
fit_intercept=True,
n_jobs=1,
normalize=False)
x = np.squeeze(wsp_his_md_point['data'].values).reshape(-1, 1)
y = np.squeeze(wsp_his_sta_point).reshape(-1, 1)
model.fit(x, y)
if (model.coef_ < 0.2):
f2 = np.polyfit(np.squeeze(x), np.squeeze(y), 2)
model2 = np.poly1d(f2)
fhours = np.arange(t_range[0], t_range[1], t_gap)
filenames = [initTime + '.' + str(fhour).zfill(3) for fhour in fhours]
t2m = utl.get_model_points_gy(dir_rqd[0],
filenames,
points,
allExists=False)
u10m = utl.get_model_points_gy(dir_rqd[1],
filenames,
points,
allExists=False)
v10m = utl.get_model_points_gy(dir_rqd[2],
filenames,
points,
allExists=False)
rh = utl.get_model_points_gy(dir_rqd[3],
filenames,
points,
allExists=False)
rn = utl.get_model_points_gy(dir_rqd[4],
filenames,
points,
allExists=False)
gust10m_predict = u10m.copy()
if (model.coef_ > 0.2):
gust10m_predict['data'].values = np.squeeze(
model.predict(
np.squeeze((u10m['data'].values**2 +
v10m['data'].values**2)**0.5).reshape(-1,
1))).reshape(
-1, 1, 1)
else:
gust10m_predict['data'].values = np.squeeze(
model2(
np.squeeze((u10m['data'].values**2 +
v10m['data'].values**2)**0.5))).reshape(-1, 1, 1)
sta_graphics.draw_point_uv_tmp_rh_rn_gust_fcst(t2m=t2m,
u10m=u10m,
v10m=v10m,
rh=rh,
rn=rn,
gust=gust10m_predict,
model='中央气象台中短期指导',
output_dir=output_dir,
points=points,
extra_info=extra_info)
def wind_rh_according_to_4D_data(
initTime=None,
fhour=6,
day_back=0,
model='ECMWF',
sta_fcs={
'lon': [101.82, 101.32, 101.84, 102.23, 102.2681],
'lat': [28.35, 27.91, 28.32, 27.82, 27.8492],
'altitude': [3600, 3034.62, 3240, 1669, 1941.5],
'name': ['健美乡', '项脚乡', '\n锦屏镇', '\n马道镇', 'S9005 ']
},
draw_zd=True,
levels=[1000, 950, 925, 900, 850, 800, 700, 600, 500],
map_ratio=19 / 9,
zoom_ratio=1,
south_China_sea=False,
area='全国',
city=False,
output_dir=None,
bkgd_type='satellite',
data_source='MICAPS'):
# micaps data directory
if (area != '全国'):
south_China_sea = False
# prepare data
if (area != '全国'):
cntr_pnt, zoom_ratio = utl.get_map_area(area_name=area)
cntr_pnt = np.append(np.mean(sta_fcs['lon']), np.mean(sta_fcs['lat']))
map_extent = [0, 0, 0, 0]
map_extent[0] = cntr_pnt[0] - zoom_ratio * 1 * map_ratio
map_extent[1] = cntr_pnt[0] + zoom_ratio * 1 * map_ratio
map_extent[2] = cntr_pnt[1] - zoom_ratio * 1
map_extent[3] = cntr_pnt[1] + zoom_ratio * 1
bkgd_level = utl.cal_background_zoom_ratio(zoom_ratio)
# micaps data directory
if (data_source == 'MICAPS'):
try:
data_dir = [
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='HGT',
lvl=''),
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='RH',
lvl=''),
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='UGRD',
lvl=''),
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='VGRD',
lvl=''),
utl.Cassandra_dir(data_type='surface',
data_source=model,
var_name='u10m'),
utl.Cassandra_dir(data_type='surface',
data_source=model,
var_name='v10m'),
utl.Cassandra_dir(data_type='surface',
data_source=model,
var_name='Td2m'),
utl.Cassandra_dir(data_type='surface',
data_source=model,
var_name='T2m')
]
except KeyError:
raise ValueError('Can not find all directories needed')
# get filename
if (initTime != None):
filename = utl.model_filename(initTime, fhour)
else:
filename = utl.filename_day_back_model(day_back=day_back,
fhour=fhour)
initTime = filename[0:8]
# retrieve data from micaps server
gh = MICAPS_IO.get_model_3D_grid(directory=data_dir[0][0:-1],
filename=filename,
levels=levels)
if (gh is None):
return
gh['data'].values = gh['data'].values * 10
rh = MICAPS_IO.get_model_3D_grid(directory=data_dir[1][0:-1],
filename=filename,
levels=levels,
allExists=False)
if rh is None:
return
u = MICAPS_IO.get_model_3D_grid(directory=data_dir[2][0:-1],
filename=filename,
levels=levels,
allExists=False)
if u is None:
return
v = MICAPS_IO.get_model_3D_grid(directory=data_dir[3][0:-1],
filename=filename,
levels=levels,
allExists=False)
if v is None:
return
u10m = MICAPS_IO.get_model_grid(directory=data_dir[4],
filename=filename)
if u10m is None:
return
v10m = MICAPS_IO.get_model_grid(directory=data_dir[5],
filename=filename)
if v10m is None:
return
td2m = MICAPS_IO.get_model_grid(directory=data_dir[6],
filename=filename)
if td2m is None:
return
t2m = MICAPS_IO.get_model_grid(directory=data_dir[7],
filename=filename)
if t2m is None:
return
if (draw_zd == True):
validtime = (datetime.strptime('20' + initTime, '%Y%m%d%H') +
timedelta(hours=fhour)).strftime("%Y%m%d%H")
directory_obs = utl.Cassandra_dir(data_type='surface',
data_source='OBS',
var_name='PLOT_ALL')
try:
zd_sta = MICAPS_IO.get_station_data(filename=validtime +
'0000.000',
directory=directory_obs,
dropna=True,
cache=False)
obs_valid = True
except:
zd_sta = MICAPS_IO.get_station_data(directory=directory_obs,
dropna=True,
cache=False)
obs_valid = False
zd_lon = zd_sta['lon'].values
zd_lat = zd_sta['lat'].values
zd_alt = zd_sta['Alt'].values
zd_u, zd_v = mpcalc.wind_components(
zd_sta['Wind_speed_2m_avg'].values * units('m/s'),
zd_sta['Wind_angle_2m_avg'].values * units.deg)
idx_zd = np.where((zd_lon > map_extent[0])
& (zd_lon < map_extent[1])
& (zd_lat > map_extent[2])
& (zd_lat < map_extent[3]))
zd_sm_lon = zd_lon[idx_zd[0]]
zd_sm_lat = zd_lat[idx_zd[0]]
zd_sm_alt = zd_alt[idx_zd[0]]
zd_sm_u = zd_u[idx_zd[0]]
zd_sm_v = zd_v[idx_zd[0]]
if (data_source == 'CIMISS'):
# get filename
if (initTime != None):
filename = utl.model_filename(initTime, fhour, UTC=True)
else:
filename = utl.filename_day_back_model(day_back=day_back,
fhour=fhour,
UTC=True)
try:
# retrieve data from CMISS server
gh = CIMISS_IO.cimiss_model_3D_grid(
data_code=utl.CMISS_data_code(data_source=model,
var_name='GPH'),
init_time_str='20' + filename[0:8],
valid_time=fhour,
levattrs={
'long_name': 'pressure_level',
'units': 'hPa',
'_CoordinateAxisType': '-'
},
fcst_levels=levels,
fcst_ele="GPH",
units='gpm')
if gh is None:
return
rh = CIMISS_IO.cimiss_model_3D_grid(
data_code=utl.CMISS_data_code(data_source=model,
var_name='RHU'),
init_time_str='20' + filename[0:8],
valid_time=fhour,
levattrs={
'long_name': 'pressure_level',
'units': 'hPa',
'_CoordinateAxisType': '-'
},
fcst_levels=levels,
fcst_ele="RHU",
units='%')
if rh is None:
return
u = CIMISS_IO.cimiss_model_3D_grid(
data_code=utl.CMISS_data_code(data_source=model,
var_name='WIU'),
init_time_str='20' + filename[0:8],
valid_time=fhour,
levattrs={
'long_name': 'pressure_level',
'units': 'hPa',
'_CoordinateAxisType': '-'
},
fcst_levels=levels,
fcst_ele="WIU",
units='m/s')
if u is None:
return
v = CIMISS_IO.cimiss_model_3D_grid(
data_code=utl.CMISS_data_code(data_source=model,
var_name='WIV'),
init_time_str='20' + filename[0:8],
valid_time=fhour,
levattrs={
'long_name': 'pressure_level',
'units': 'hPa',
'_CoordinateAxisType': '-'
},
fcst_levels=levels,
fcst_ele="WIV",
units='m/s')
if v is None:
return
if (model == 'ECMWF'):
td2m = CIMISS_IO.cimiss_model_by_time(
'20' + filename[0:8],
valid_time=fhour,
data_code=utl.CMISS_data_code(data_source=model,
var_name='DPT'),
levattrs={
'long_name': 'height_above_ground',
'units': 'm',
'_CoordinateAxisType': '-'
},
fcst_level=0,
fcst_ele="DPT",
units='K')
if td2m is None:
return
t2m = CIMISS_IO.cimiss_model_by_time(
'20' + filename[0:8],
valid_time=fhour,
data_code=utl.CMISS_data_code(data_source=model,
var_name='TEF2'),
levattrs={
'long_name': 'height_above_ground',
'units': 'm',
'_CoordinateAxisType': '-'
},
fcst_level=0,
fcst_ele="TEF2",
units='K')
if t2m is None:
return
v10m = CIMISS_IO.cimiss_model_by_time(
'20' + filename[0:8],
valid_time=fhour,
data_code=utl.CMISS_data_code(data_source=model,
var_name='WIV10'),
levattrs={
'long_name': 'height_above_ground',
'units': 'm',
'_CoordinateAxisType': '-'
},
fcst_level=0,
fcst_ele="WIV10",
units='m/s')
if v10m is None:
return
u10m = CIMISS_IO.cimiss_model_by_time(
'20' + filename[0:8],
valid_time=fhour,
data_code=utl.CMISS_data_code(data_source=model,
var_name='WIU10'),
levattrs={
'long_name': 'height_above_ground',
'units': 'm',
'_CoordinateAxisType': '-'
},
fcst_level=0,
fcst_ele="WIU10",
units='m/s')
if u10m is None:
return
if (model == 'GRAPES_GFS'):
rh2m = CIMISS_IO.cimiss_model_by_time(
'20' + filename[0:8],
valid_time=fhour,
data_code=utl.CMISS_data_code(data_source=model,
var_name='RHF2'),
levattrs={
'long_name': 'height_above_ground',
'units': 'm',
'_CoordinateAxisType': '-'
},
fcst_level=2,
fcst_ele="RHF2",
units='%')
if rh2m is None:
return
v10m = CIMISS_IO.cimiss_model_by_time(
'20' + filename[0:8],
valid_time=fhour,
data_code=utl.CMISS_data_code(data_source=model,
var_name='WIV10'),
levattrs={
'long_name': 'height_above_ground',
'units': 'm',
'_CoordinateAxisType': '-'
},
fcst_level=10,
fcst_ele="WIV10",
units='m/s')
if v10m is None:
return
u10m = CIMISS_IO.cimiss_model_by_time(
'20' + filename[0:8],
valid_time=fhour,
data_code=utl.CMISS_data_code(data_source=model,
var_name='WIU10'),
levattrs={
'long_name': 'height_above_ground',
'units': 'm',
'_CoordinateAxisType': '-'
},
fcst_level=10,
fcst_ele="WIU10",
units='m/s')
if u10m is None:
return
except KeyError:
raise ValueError('Can not find all data needed')
if (draw_zd == True):
if (initTime == None):
initTime1 = CIMISS_IO.cimiss_get_obs_latest_time(
data_code="SURF_CHN_MUL_HOR")
initTime = (datetime.strptime('20' + initTime1, '%Y%m%d%H') -
timedelta(days=day_back)).strftime("%Y%m%d%H")[2:]
validtime = (datetime.strptime('20' + initTime, '%Y%m%d%H') +
timedelta(hours=fhour)).strftime("%Y%m%d%H")
data_code = utl.CMISS_data_code(data_source='OBS',
var_name='PLOT_sfc')
zd_sta = CIMISS_IO.cimiss_obs_by_time(
times=validtime + '0000',
data_code=data_code,
sta_levels="011,012,013,014",
elements=
"Station_Id_C,Station_Id_d,lat,lon,Alti,TEM,WIN_D_Avg_2mi,WIN_S_Avg_2mi,RHU"
)
obs_valid = True
if (zd_sta is None):
CIMISS_IO.cimiss_get_obs_latest_time(data_code=data_code,
latestTime=6)
zd_sta = CIMISS_IO.cimiss_obs_by_time(directory=directory_obs,
dropna=True,
cache=False)
obs_valid = False
zd_lon = zd_sta['lon'].values
zd_lat = zd_sta['lat'].values
zd_alt = zd_sta['Alti'].values
zd_u, zd_v = mpcalc.wind_components(
zd_sta['WIN_S_Avg_2mi'].values * units('m/s'),
zd_sta['WIN_D_Avg_2mi'].values * units.deg)
idx_zd = np.where((zd_lon > map_extent[0])
& (zd_lon < map_extent[1])
& (zd_lat > map_extent[2])
& (zd_lat < map_extent[3])
& (zd_sta['WIN_S_Avg_2mi'].values < 1000))
zd_sm_lon = zd_lon[idx_zd[0]]
zd_sm_lat = zd_lat[idx_zd[0]]
zd_sm_alt = zd_alt[idx_zd[0]]
zd_sm_u = zd_u[idx_zd[0]]
zd_sm_v = zd_v[idx_zd[0]]
#maskout area
delt_xy = rh['lon'].values[1] - rh['lon'].values[0]
#+ to solve the problem of labels on all the contours
mask1 = (rh['lon'] > map_extent[0] - delt_xy) & (
rh['lon'] < map_extent[1] + delt_xy) & (
rh['lat'] > map_extent[2] - delt_xy) & (rh['lat'] <
map_extent[3] + delt_xy)
mask2 = (u10m['lon'] > map_extent[0] - delt_xy) & (
u10m['lon'] < map_extent[1] + delt_xy) & (
u10m['lat'] > map_extent[2] - delt_xy) & (u10m['lat'] <
map_extent[3] + delt_xy)
#- to solve the problem of labels on all the contours
rh = rh.where(mask1, drop=True)
u = u.where(mask1, drop=True)
v = v.where(mask1, drop=True)
gh = gh.where(mask1, drop=True)
u10m = u10m.where(mask2, drop=True)
v10m = v10m.where(mask2, drop=True)
#prepare interpolator
Ex1 = np.squeeze(u['data'].values).flatten()
Ey1 = np.squeeze(v['data'].values).flatten()
Ez1 = np.squeeze(rh['data'].values).flatten()
z = (np.squeeze(gh['data'].values)).flatten()
coords = np.zeros((np.size(levels), u['lat'].size, u['lon'].size, 3))
coords[..., 1] = u['lat'].values.reshape((1, u['lat'].size, 1))
coords[..., 2] = u['lon'].values.reshape((1, 1, u['lon'].size))
coords = coords.reshape((Ex1.size, 3))
coords[:, 0] = z
interpolator_U = LinearNDInterpolator(coords, Ex1, rescale=True)
interpolator_V = LinearNDInterpolator(coords, Ey1, rescale=True)
interpolator_RH = LinearNDInterpolator(coords, Ez1, rescale=True)
#process sta_fcs 10m wind
coords2 = np.zeros((np.size(sta_fcs['lon']), 3))
coords2[:, 0] = sta_fcs['altitude']
coords2[:, 1] = sta_fcs['lat']
coords2[:, 2] = sta_fcs['lon']
u_sta = interpolator_U(coords2)
v_sta = interpolator_V(coords2)
RH_sta = interpolator_RH(coords2)
wsp_sta = (u_sta**2 + v_sta**2)**0.5
u10m_2D = u10m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))
v10m_2D = v10m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))
if (model == 'GRAPES_GFS' and data_source == 'CIMISS'):
rh2m_2D = rh2m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))['data'].values
else:
td2m_2D = td2m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))
t2m_2D = t2m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))
if (data_source == 'MICAPS'):
rh2m_2D = mpcalc.relative_humidity_from_dewpoint(
t2m_2D['data'].values * units('degC'),
td2m_2D['data'].values * units('degC')) * 100
else:
rh2m_2D = mpcalc.relative_humidity_from_dewpoint(
t2m_2D['data'].values * units('kelvin'),
td2m_2D['data'].values * units('kelvin')) * 100
wsp10m_2D = (u10m_2D['data'].values**2 + v10m_2D['data'].values**2)**0.5
winddir10m = mpcalc.wind_direction(u10m_2D['data'].values * units('m/s'),
v10m_2D['data'].values * units('m/s'))
if (np.isnan(wsp_sta).any()):
if (wsp_sta.size == 1):
wsp_sta[np.isnan(wsp_sta)] = np.squeeze(
wsp10m_2D[np.isnan(wsp_sta)])
RH_sta[np.isnan(RH_sta)] = np.squeeze(
np.array(rh2m_2D)[np.isnan(RH_sta)])
else:
wsp_sta[np.isnan(wsp_sta)] = np.squeeze(wsp10m_2D)[np.isnan(
wsp_sta)]
RH_sta[np.isnan(RH_sta)] = np.squeeze(
np.array(rh2m_2D))[np.isnan(RH_sta)]
u_sta, v_sta = mpcalc.wind_components(wsp_sta * units('m/s'), winddir10m)
#process zd_sta 10m wind
zd_fcst_obs = None
if (draw_zd is True):
coords3 = np.zeros((np.size(zd_sm_alt), 3))
coords3[:, 0] = zd_sm_alt
coords3[:, 1] = zd_sm_lat
coords3[:, 2] = zd_sm_lon
u_sm_sta = interpolator_U(coords3)
v_sm_sta = interpolator_V(coords3)
wsp_sm_sta = (u_sm_sta**2 + v_sm_sta**2)**0.5
u10m_sm = u10m.interp(lon=('points', zd_sm_lon),
lat=('points', zd_sm_lat))
v10m_sm = v10m.interp(lon=('points', zd_sm_lon),
lat=('points', zd_sm_lat))
wsp10m_sta = np.squeeze(
(u10m_sm['data'].values**2 + v10m_sm['data'].values**2)**0.5)
winddir10m_sm = mpcalc.wind_direction(
u10m_sm['data'].values * units('m/s'),
v10m_sm['data'].values * units('m/s'))
if (np.isnan(wsp_sm_sta).any()):
wsp_sm_sta[np.isnan(wsp_sm_sta)] = wsp10m_sta[np.isnan(wsp_sm_sta)]
u_sm_sta, v_sm_sta = mpcalc.wind_components(wsp_sm_sta * units('m/s'),
winddir10m_sm)
zd_fcst_obs = {
'lon': zd_sm_lon,
'lat': zd_sm_lat,
'altitude': zd_sm_alt,
'U': np.squeeze(np.array(u_sm_sta)),
'V': np.squeeze(np.array(v_sm_sta)),
'obs_valid': obs_valid,
'U_obs': np.squeeze(np.array(zd_sm_u)),
'V_obs': np.squeeze(np.array(zd_sm_v))
}
#prepare for graphics
sta_fcs_fcst = {
'lon': sta_fcs['lon'],
'lat': sta_fcs['lat'],
'altitude': sta_fcs['altitude'],
'name': sta_fcs['name'],
'RH': np.array(RH_sta),
'U': np.squeeze(np.array(u_sta)),
'V': np.squeeze(np.array(v_sta))
}
fcst_info = gh.coords
local_scale_graphics.draw_wind_rh_according_to_4D_data(
sta_fcs_fcst=sta_fcs_fcst,
zd_fcst_obs=zd_fcst_obs,
fcst_info=fcst_info,
map_extent=map_extent,
draw_zd=draw_zd,
bkgd_type=bkgd_type,
bkgd_level=bkgd_level,
output_dir=None)
def wind_temp_rn_according_to_4D_data(
initTime=None,
fhour=6,
day_back=0,
model='ECMWF',
sta_fcs={
'lon': [101.82, 101.32, 101.84, 102.23, 102.2681],
'lat': [28.35, 27.91, 28.32, 27.82, 27.8492],
'altitude': [3600, 3034.62, 3240, 1669, 1941.5],
'name': ['健美乡', '项脚乡', '\n锦屏镇', '\n马道镇', 'S9005 ']
},
draw_zd=True,
levels=[
1000, 950, 925, 900, 850, 800, 700, 600, 500, 400, 300, 250, 200,
150
],
map_ratio=19 / 9,
zoom_ratio=1,
south_China_sea=False,
area=None,
city=False,
output_dir=None,
bkgd_type='satellite',
data_source='MICAPS',
**kwargs):
# micaps data directory
if (area != None):
south_China_sea = False
# prepare data
if (area != None):
cntr_pnt, zoom_ratio = utl.get_map_area(area_name=area)
cntr_pnt = np.append(np.mean(sta_fcs['lon']), np.mean(sta_fcs['lat']))
map_extent = [0, 0, 0, 0]
map_extent[0] = cntr_pnt[0] - zoom_ratio * 1 * map_ratio
map_extent[1] = cntr_pnt[0] + zoom_ratio * 1 * map_ratio
map_extent[2] = cntr_pnt[1] - zoom_ratio * 1
map_extent[3] = cntr_pnt[1] + zoom_ratio * 1
bkgd_level = utl.cal_background_zoom_ratio(zoom_ratio)
# micaps data directory
if (data_source == 'MICAPS'):
try:
data_dir = [
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='HGT',
lvl=''),
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='TMP',
lvl=''),
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='UGRD',
lvl=''),
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='VGRD',
lvl=''),
utl.Cassandra_dir(data_type='surface',
data_source=model,
var_name='u10m'),
utl.Cassandra_dir(data_type='surface',
data_source=model,
var_name='v10m'),
utl.Cassandra_dir(data_type='surface',
data_source=model,
var_name='Td2m'),
utl.Cassandra_dir(data_type='surface',
data_source=model,
var_name='T2m')
]
except KeyError:
raise ValueError('Can not find all directories needed')
# get filename
if (initTime != None):
filename = utl.model_filename(initTime, fhour)
else:
filename = utl.filename_day_back_model(day_back=day_back,
fhour=fhour)
initTime = filename[0:8]
# retrieve data from micaps server
gh = MICAPS_IO.get_model_3D_grid(directory=data_dir[0][0:-1],
filename=filename,
levels=levels)
if (gh is None):
return
gh['data'].values = gh['data'].values * 10
TMP = MICAPS_IO.get_model_3D_grid(directory=data_dir[1][0:-1],
filename=filename,
levels=levels,
allExists=False)
if TMP is None:
return
u = MICAPS_IO.get_model_3D_grid(directory=data_dir[2][0:-1],
filename=filename,
levels=levels,
allExists=False)
if u is None:
return
v = MICAPS_IO.get_model_3D_grid(directory=data_dir[3][0:-1],
filename=filename,
levels=levels,
allExists=False)
if v is None:
return
u10m = MICAPS_IO.get_model_grid(directory=data_dir[4],
filename=filename)
if u10m is None:
return
v10m = MICAPS_IO.get_model_grid(directory=data_dir[5],
filename=filename)
if v10m is None:
return
td2m = MICAPS_IO.get_model_grid(directory=data_dir[6],
filename=filename)
if td2m is None:
return
t2m = MICAPS_IO.get_model_grid(directory=data_dir[7],
filename=filename)
if t2m is None:
return
if (draw_zd == True):
validtime = (datetime.strptime('20' + initTime, '%Y%m%d%H') +
timedelta(hours=fhour)).strftime("%Y%m%d%H")
directory_obs = utl.Cassandra_dir(data_type='surface',
data_source='OBS',
var_name='PLOT_ALL')
try:
zd_sta = MICAPS_IO.get_station_data(filename=validtime +
'0000.000',
directory=directory_obs,
dropna=True,
cache=False)
obs_valid = True
except:
zd_sta = MICAPS_IO.get_station_data(directory=directory_obs,
dropna=True,
cache=False)
obs_valid = False
zd_lon = zd_sta['lon'].values
zd_lat = zd_sta['lat'].values
zd_alt = zd_sta['Alt'].values
zd_u, zd_v = mpcalc.wind_components(
zd_sta['Wind_speed_2m_avg'].values * units('m/s'),
zd_sta['Wind_angle_2m_avg'].values * units.deg)
idx_zd = np.where((zd_lon > map_extent[0])
& (zd_lon < map_extent[1])
& (zd_lat > map_extent[2])
& (zd_lat < map_extent[3]))
zd_sm_lon = zd_lon[idx_zd[0]]
zd_sm_lat = zd_lat[idx_zd[0]]
zd_sm_alt = zd_alt[idx_zd[0]]
zd_sm_u = zd_u[idx_zd[0]]
zd_sm_v = zd_v[idx_zd[0]]
#maskout area
delt_xy = TMP['lon'].values[1] - TMP['lon'].values[0]
#+ to solve the problem of labels on all the contours
mask1 = (TMP['lon'] > map_extent[0] - delt_xy) & (
TMP['lon'] < map_extent[1] + delt_xy) & (
TMP['lat'] > map_extent[2] - delt_xy) & (TMP['lat'] <
map_extent[3] + delt_xy)
mask2 = (u10m['lon'] > map_extent[0] - delt_xy) & (
u10m['lon'] < map_extent[1] + delt_xy) & (
u10m['lat'] > map_extent[2] - delt_xy) & (u10m['lat'] <
map_extent[3] + delt_xy)
#- to solve the problem of labels on all the contours
TMP = TMP.where(mask1, drop=True)
u = u.where(mask1, drop=True)
v = v.where(mask1, drop=True)
gh = gh.where(mask1, drop=True)
u10m = u10m.where(mask2, drop=True)
v10m = v10m.where(mask2, drop=True)
#prepare interpolator
Ex1 = np.squeeze(u['data'].values).flatten()
Ey1 = np.squeeze(v['data'].values).flatten()
Ez1 = np.squeeze(TMP['data'].values).flatten()
z = (np.squeeze(gh['data'].values)).flatten()
coords = np.zeros((np.size(levels), u['lat'].size, u['lon'].size, 3))
coords[..., 1] = u['lat'].values.reshape((1, u['lat'].size, 1))
coords[..., 2] = u['lon'].values.reshape((1, 1, u['lon'].size))
coords = coords.reshape((Ex1.size, 3))
coords[:, 0] = z
interpolator_U = LinearNDInterpolator(coords, Ex1, rescale=True)
interpolator_V = LinearNDInterpolator(coords, Ey1, rescale=True)
interpolator_TMP = LinearNDInterpolator(coords, Ez1, rescale=True)
#process sta_fcs 10m wind
coords2 = np.zeros((np.size(sta_fcs['lon']), 3))
coords2[:, 0] = sta_fcs['altitude']
coords2[:, 1] = sta_fcs['lat']
coords2[:, 2] = sta_fcs['lon']
u_sta = interpolator_U(coords2)
v_sta = interpolator_V(coords2)
TMP_sta = interpolator_TMP(coords2)
wsp_sta = (u_sta**2 + v_sta**2)**0.5
u10m_2D = u10m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))
v10m_2D = v10m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))
td2m_2D = td2m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))
t2m_2D = t2m.interp(lon=('points', sta_fcs['lon']),
lat=('points', sta_fcs['lat']))
wsp10m_2D = (u10m_2D['data'].values**2 + v10m_2D['data'].values**2)**0.5
winddir10m = mpcalc.wind_direction(u10m_2D['data'].values * units('m/s'),
v10m_2D['data'].values * units('m/s'))
if (np.isnan(wsp_sta).any()):
if (wsp_sta.size == 1):
wsp_sta[np.isnan(wsp_sta)] = np.squeeze(
wsp10m_2D[np.isnan(wsp_sta)])
TMP_sta[np.isnan(TMP_sta)] = np.squeeze(
np.array(t2m_2D)[np.isnan(TMP_sta)])
else:
wsp_sta[np.isnan(wsp_sta)] = np.squeeze(wsp10m_2D)[np.isnan(
wsp_sta)]
TMP_sta[np.isnan(TMP_sta)] = np.squeeze(
np.array(t2m_2D))[np.isnan(TMP_sta)]
u_sta, v_sta = mpcalc.wind_components(wsp_sta * units('m/s'), winddir10m)
#process zd_sta 10m wind
zd_fcst_obs = None
if (draw_zd is True):
coords3 = np.zeros((np.size(zd_sm_alt), 3))
coords3[:, 0] = zd_sm_alt
coords3[:, 1] = zd_sm_lat
coords3[:, 2] = zd_sm_lon
u_sm_sta = interpolator_U(coords3)
v_sm_sta = interpolator_V(coords3)
wsp_sm_sta = (u_sm_sta**2 + v_sm_sta**2)**0.5
u10m_sm = u10m.interp(lon=('points', zd_sm_lon),
lat=('points', zd_sm_lat))
v10m_sm = v10m.interp(lon=('points', zd_sm_lon),
lat=('points', zd_sm_lat))
wsp10m_sta = np.squeeze(
(u10m_sm['data'].values**2 + v10m_sm['data'].values**2)**0.5)
winddir10m_sm = mpcalc.wind_direction(
u10m_sm['data'].values * units('m/s'),
v10m_sm['data'].values * units('m/s'))
if (np.isnan(wsp_sm_sta).any()):
wsp_sm_sta[np.isnan(wsp_sm_sta)] = wsp10m_sta[np.isnan(wsp_sm_sta)]
for ista in range(0, len(wsp10m_sta)):
if (wsp10m_sta[ista] > wsp_sm_sta[ista]):
wsp_sm_sta[ista] = wsp10m_sta[ista]
u_sm_sta, v_sm_sta = mpcalc.wind_components(wsp_sm_sta * units('m/s'),
winddir10m_sm)
zd_fcst_obs = {
'lon': zd_sm_lon,
'lat': zd_sm_lat,
'altitude': zd_sm_alt,
'U': np.squeeze(np.array(u_sm_sta)),
'V': np.squeeze(np.array(v_sm_sta)),
'obs_valid': obs_valid,
'U_obs': np.squeeze(np.array(zd_sm_u)),
'V_obs': np.squeeze(np.array(zd_sm_v))
}
#prepare for graphics
sta_fcs_fcst = {
'lon': sta_fcs['lon'],
'lat': sta_fcs['lat'],
'altitude': sta_fcs['altitude'],
'name': sta_fcs['name'],
'TMP': np.array(TMP_sta),
'U': np.squeeze(np.array(u_sta)),
'V': np.squeeze(np.array(v_sta))
}
fcst_info = gh.coords
local_scale_graphics.draw_wind_temp_according_to_4D_data(
sta_fcs_fcst=sta_fcs_fcst,
zd_fcst_obs=zd_fcst_obs,
fcst_info=fcst_info,
map_extent=map_extent,
draw_zd=draw_zd,
bkgd_type=bkgd_type,
bkgd_level=bkgd_level,
output_dir=output_dir)
def IR_Sounding_GeopotentialHeight(Plot_IR=True,
Plot_Sounding=True,
Plot_HGT=True,
IR_time=None,
Sounding_time=None,
HGT_initTime=None,
fhour=24,
model='ECMWF',
map_ratio=19 / 9,
zoom_ratio=20,
cntr_pnt=[102, 34],
city=False,
Channel='C009',
south_China_sea=True,
area='全国',
output_dir=None,
data_source='MICAPS'):
Sounding = None
HGT = None
IR = None
if (data_source == 'MICAPS'):
try:
data_dir = [
utl.Cassandra_dir(data_type='high',
data_source='OBS',
var_name='FY4AL1',
lvl=Channel),
utl.Cassandra_dir(data_type='high',
data_source='OBS',
var_name='PLOT',
lvl='500'),
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='HGT',
lvl='500')
]
except KeyError:
raise ValueError('Can not find all directories needed')
if (Plot_IR is True):
if (IR_time != None):
filename_IR = Channel + '_20' + IR_time + '0000_FY4A.AWX'
IR = get_fy_awx(data_dir[0], filename=filename_IR)
else:
IR = get_fy_awx(data_dir[0])
if (Plot_Sounding is True):
if (Sounding_time != None):
filename_Sounding = '20' + Sounding_time + '0000.000'
Sounding = get_station_data(data_dir[1],
filename=filename_Sounding)
else:
Sounding = get_station_data(data_dir[1])
if (Plot_HGT is True):
if (HGT_initTime != None):
filename = model_filename(HGT_initTime, fhour)
HGT = get_model_grid(data_dir[2], filename=filename)
else:
HGT = get_model_grid(data_dir[2])
if (area != '全国'):
cntr_pnt, zoom_ratio = get_map_area(area_name=area)
south_China_sea = False
map_extent = [0, 0, 0, 0]
map_extent[0] = cntr_pnt[0] - zoom_ratio * 1 * map_ratio
map_extent[1] = cntr_pnt[0] + zoom_ratio * 1 * map_ratio
map_extent[2] = cntr_pnt[1] - zoom_ratio * 1
map_extent[3] = cntr_pnt[1] + zoom_ratio * 1
delt_x = (map_extent[1] - map_extent[0]) * 0.2
delt_y = (map_extent[3] - map_extent[2]) * 0.1
if (Plot_HGT is True):
mask1 = (HGT['lon'] > map_extent[0] - delt_x) & (
HGT['lon'] < map_extent[1] + delt_x) & (
HGT['lat'] > map_extent[2] - delt_y) & (HGT['lat'] <
map_extent[3] + delt_y)
HGT = HGT.where(mask1, drop=True)
if (output_dir != None):
output_dir = output_dir + area + '_'
observation_graphics.OBS_Sounding_GeopotentialHeight(
IR=IR,
Sounding=Sounding,
HGT=HGT,
map_extent=map_extent,
city=city,
south_China_sea=south_China_sea,
output_dir=output_dir,
Channel=Channel)
def CREF_Sounding_GeopotentialHeight(Plot_CREF=True,
Plot_Sounding=True,
Plot_HGT=True,
CREF_time=None,
Sounding_time=None,
HGT_initTime=None,
fhour=24,
model='ECMWF',
map_ratio=14 / 9,
zoom_ratio=20,
cntr_pnt=[104, 34],
city=False,
Channel='C009',
south_China_sea=True,
area=None,
output_dir=None,
data_source='MICAPS',
**kwargs):
Sounding = None
HGT = None
IR = None
if (data_source == 'MICAPS'):
try:
data_dir = [
utl.Cassandra_dir(data_type='surface',
data_source='OBS',
var_name='CREF'),
utl.Cassandra_dir(data_type='high',
data_source='OBS',
var_name='PLOT',
lvl='500'),
utl.Cassandra_dir(data_type='high',
data_source=model,
var_name='HGT',
lvl='500')
]
except KeyError:
raise ValueError('Can not find all directories needed')
if (Plot_CREF is True):
if (CREF_time != None):
filename_CREF = 'ACHN.CREF000.20' + CREF_time[
0:6] + '.' + CREF_time[6:8] + '0000.LATLON'
CREF = get_radar_mosaic(data_dir[0], filename=filename_CREF)
else:
CREF = get_radar_mosaic(data_dir[0])
if (Plot_Sounding is True):
if (Sounding_time != None):
filename_Sounding = '20' + Sounding_time + '0000.000'
Sounding = get_station_data(data_dir[1],
filename=filename_Sounding)
else:
Sounding = get_station_data(data_dir[1])
if (Plot_HGT is True):
if (HGT_initTime != None):
filename = model_filename(HGT_initTime, fhour)
HGT = get_model_grid(data_dir[2], filename=filename)
else:
HGT = get_model_grid(data_dir[2])
if (area != None):
cntr_pnt, zoom_ratio = get_map_area(area_name=area)
south_China_sea = False
CREF.coords['time'].values[0] = datetime.strptime(CREF_time, '%y%m%d%H')
map_extent = [0, 0, 0, 0]
map_extent[0] = cntr_pnt[0] - zoom_ratio * 1 * map_ratio
map_extent[1] = cntr_pnt[0] + zoom_ratio * 1 * map_ratio
map_extent[2] = cntr_pnt[1] - zoom_ratio * 1
map_extent[3] = cntr_pnt[1] + zoom_ratio * 1
delt_x = (map_extent[1] - map_extent[0]) * 0.2
delt_y = (map_extent[3] - map_extent[2]) * 0.1
if (Plot_HGT is True):
mask1 = (HGT['lon'] > map_extent[0] - delt_x) & (
HGT['lon'] < map_extent[1] + delt_x) & (
HGT['lat'] > map_extent[2] - delt_y) & (HGT['lat'] <
map_extent[3] + delt_y)
HGT = HGT.where(mask1, drop=True)
if (output_dir != None):
output_dir = output_dir + area + '_'
observation_graphics.OBS_CREF_Sounding_GeopotentialHeight(
CREF=CREF,
Sounding=Sounding,
HGT=HGT,
map_extent=map_extent,
city=city,
south_China_sea=south_China_sea,
output_dir=output_dir)
