def get_sounding(station): ###################################### Collect Sounding ################################################ cache = settings.AppCache #Retrieves Sounding Details and returns them #If soundings are cached and valid, returns the cache, otherwise retreive new sounding key='sounding_'+str(station) df = cache.get(key) if df is not None: #Get sounding from cache and return it logging.info("Sounding Cache Hit") print("Sounding Cahce Hit") return df else: logging.info("Cache Miss") print("Cahce Miss") today = datetime.utcnow() if today.hour<1: #If date is not yet 02:00 make it yesterday... :) today = datetime.utcnow() - timedelta(days=1) print("Trying yesterday's sounding data",file=sys.stdout) if (today.hour > 13): hour = 12 else: hour = 0 try: date = datetime(today.year, today.month, today.day, hour) df = WyomingUpperAir.request_data(date, station) cache.set(key, df, expire=1800,tag='Sounding Data ') #TODO GET LATEST DATE WHEN AVAILABLE except Exception as e: if (hour==12): hour = 0 print("Unable to retriece 12Z data attempting 00Z data",file=sys.stderr) try: date = datetime(today.year, today.month, today.day, hour) station = '40179' df = WyomingUpperAir.request_data(date, station) #TODO GET LATEST DATE WHEN AVAILABLE cache.set(key, df, expire=1800,tag='Sounding Data ') except Exception as e: print(e,file=sys.stderr) sys.exit(-1) else: print(e,file=sys.stderr) sys.exit(-1) return df
def read_web(self, date): #Pull down the sounding sounding = WyomingUpperAir.request_data(date, self.fpath) #Convert sounding to proper data format and attach to PySonde object self.release_time = datetime.utcfromtimestamp( sounding["time"].values[0].tolist() / 1e9) self.release_site = sounding["station"].values[0] self.release_lat = sounding["latitude"].values[0] * mu( sounding.units["latitude"]).to(mu.deg) self.release_lon = sounding["longitude"].values[0] * mu( sounding.units["longitude"]).to(mu.deg) self.release_elv = sounding["elevation"].values[0] * mu( sounding.units["elevation"]).to(mu.meter) skeys = ["pres", "temp", "dewp", "uwind", "vwind", "lon", "lat", "alt"] wkeys = [ "pressure", "temperature", "dewpoint", "u_wind", "v_wind", "longitude", "latitude", "height" ] for sk, wk in zip(skeys, wkeys): self.sounding[sk] = sounding[wk].values * mu( sounding.units[wk]).to(self.sounding_units[sk]) #Fill in time array with Nans self.sounding["time"] = numpy.ones( self.sounding["pres"].shape) * numpy.nan #Ensure that heights are AMSL and not AGL if (self.sounding["alt"][0] < self.release_elv): self.sounding["alt"] += self.release_elv #Returning return
def acquire_sounding_wind_data(date, station): """ Get sounding data using siphon, extract necessary variables and return a dictionary with heigth and wind data for pyart FourDD algorithm. Parameters ---------- date: date of the sounding (datetime.datetime) station: name of the METAR sounding station Returns ------- d: "dictionary" of sounding wind data """ sounding = WyomingUpperAir.request_data(date, station) sounding = sounding.dropna(subset=('height', 'speed', 'direction', 'u_wind', 'v_wind'), how='all') height = sounding['height'].values speed = sounding['speed'].values direction = sounding['direction'].values lat = sounding['latitude'].values lon = sounding['longitude'].values profile = HorizontalWindProfile(height, speed, direction, latitude=lat, longitude=lon) return profile
def test_wyoming_no_station(): """Test that we handle stations with no ID from the Wyoming archive.""" df = WyomingUpperAir.request_data(datetime(1976, 3, 4, 0), '72349') assert (df['time'][0] == datetime(1976, 3, 4)) assert (df['station'][0] == '') assert (df['station_number'][0] == 72349) assert (df['latitude'][0] == 36.88) assert (df['longitude'][0] == -93.9) assert (df['elevation'][0] == 438.0) assert_almost_equal(df['pressure'][5], 884.0, 2) assert_almost_equal(df['height'][5], 1140, 2) assert_almost_equal(df['temperature'][5], 14.6, 2) assert_almost_equal(df['dewpoint'][5], 12.8, 2) assert_almost_equal(df['u_wind'][5], -10.940, 2) assert_almost_equal(df['v_wind'][5], 25.774, 2) assert_almost_equal(df['speed'][5], 28.0, 1) assert_almost_equal(df['direction'][5], 157.0, 1) assert (df.units['pressure'] == 'hPa') assert (df.units['height'] == 'meter') assert (df.units['temperature'] == 'degC') assert (df.units['dewpoint'] == 'degC') assert (df.units['u_wind'] == 'knot') assert (df.units['v_wind'] == 'knot') assert (df.units['speed'] == 'knot') assert (df.units['direction'] == 'degrees') assert (df.units['latitude'] == 'degrees') assert (df.units['longitude'] == 'degrees') assert (df.units['elevation'] == 'meter') assert (df.units['station'] is None) assert (df.units['station_number'] is None) assert (df.units['time'] is None)
def test_wyoming(): """Test that we are properly parsing data from the Wyoming archive.""" df = WyomingUpperAir.request_data(datetime(1999, 5, 4, 0), 'OUN') assert (df['time'][0] == datetime(1999, 5, 4, 0)) assert (df['station'][0] == 'OUN') assert (df['station_number'][0] == 72357) assert (df['latitude'][0] == 35.18) assert (df['longitude'][0] == -97.44) assert (df['elevation'][0] == 345.0) assert_almost_equal(df['pressure'][5], 867.9, 2) assert_almost_equal(df['height'][5], 1219., 2) assert_almost_equal(df['temperature'][5], 17.4, 2) assert_almost_equal(df['dewpoint'][5], 14.3, 2) assert_almost_equal(df['u_wind'][5], 6.60, 2) assert_almost_equal(df['v_wind'][5], 37.42, 2) assert_almost_equal(df['speed'][5], 38.0, 1) assert_almost_equal(df['direction'][5], 190.0, 1) assert (df.units['pressure'] == 'hPa') assert (df.units['height'] == 'meter') assert (df.units['temperature'] == 'degC') assert (df.units['dewpoint'] == 'degC') assert (df.units['u_wind'] == 'knot') assert (df.units['v_wind'] == 'knot') assert (df.units['speed'] == 'knot') assert (df.units['direction'] == 'degrees') assert (df.units['latitude'] == 'degrees') assert (df.units['longitude'] == 'degrees') assert (df.units['elevation'] == 'meter') assert (df.units['station'] is None) assert (df.units['station_number'] is None) assert (df.units['time'] is None)
def read_upper_air_uwyo(date, p_lvl): pressures = np.full((len(stations)), np.nan) heights = np.full((len(stations)), np.nan) temperatures = np.full((len(stations)), np.nan) lats = np.full((len(stations)), np.nan) lons = np.full((len(stations)), np.nan) wspd = np.full((len(stations)), np.nan) wdir = np.full((len(stations)), np.nan) for ii, stn in enumerate(stations): print(stn, p_lvl) #################################################### # Make the request (a pandas dataframe is returned). try: df = WyomingUpperAir.request_data(date, stn) except ValueError: print("No data for station", stn) continue ##!##################################################### ##!## Units are stored in a dictionary with the variable name as the key in the `units` attribute ##!## of the dataframe. ##!#print(df.units) ##!# ##!##################################################### ##!#print(df.units['pressure']) ##!##################################################### ##!## Units can then be attached to the values from the dataframe. ##!#pressure = df['pressure'].values * units(df.units['pressure']) ##!#temperature = df['temperature'].values * units(df.units['temperature']) ##!#dewpoint = df['dewpoint'].values * units(df.units['dewpoint']) ##!#u_wind = df['u_wind'].values * units(df.units['u_wind']) ##!#v_wind = df['v_wind'].values * units(df.units['v_wind']) if (np.min(df['pressure']) > p_lvl): print("ERROR: ", stn, " data not high enough") continue else: pressures[ii] = df['pressure'][df['pressure'] == p_lvl] heights[ii] = df['height'][df['pressure'] == p_lvl] temperatures[ii] = df['temperature'][df['pressure'] == p_lvl] lats[ii] = df['latitude'][df['pressure'] == p_lvl] lons[ii] = df['longitude'][df['pressure'] == p_lvl] wspd[ii] = df['speed'][df['pressure'] == p_lvl] wdir[ii] = df['direction'][df['pressure'] == p_lvl] out_dict = {} out_dict['stations'] = stations out_dict['pressures'] = pressures out_dict['heights'] = heights out_dict['temperatures'] = temperatures out_dict['lats'] = lats out_dict['lons'] = lons out_dict['wspd'] = wspd out_dict['wdir'] = wdir return out_dict
def test_high_alt_wyoming(): """Test Wyoming data that starts at pressure less than 925 hPa.""" df = WyomingUpperAir.request_data(datetime(2010, 12, 9, 12), 'BOI') assert (df['time'][0] == datetime(2010, 12, 9, 12)) assert (df['station'][0] == 'BOI') assert (df['station_number'][0] == 72681) assert (df['latitude'][0] == 43.56) assert (df['longitude'][0] == -116.21) assert (df['elevation'][0] == 874.0) assert_almost_equal(df['pressure'][2], 890.0, 2) assert_almost_equal(df['height'][2], 1133., 2) assert_almost_equal(df['temperature'][2], 5.4, 2) assert_almost_equal(df['dewpoint'][2], 3.9, 2) assert_almost_equal(df['u_wind'][2], -0.42, 2) assert_almost_equal(df['v_wind'][2], 5.99, 2) assert_almost_equal(df['speed'][2], 6.0, 1) assert_almost_equal(df['direction'][2], 176.0, 1) assert (df.units['pressure'] == 'hPa') assert (df.units['height'] == 'meter') assert (df.units['temperature'] == 'degC') assert (df.units['dewpoint'] == 'degC') assert (df.units['u_wind'] == 'knot') assert (df.units['v_wind'] == 'knot') assert (df.units['speed'] == 'knot') assert (df.units['direction'] == 'degrees') assert (df.units['latitude'] == 'degrees') assert (df.units['longitude'] == 'degrees') assert (df.units['elevation'] == 'meter') assert (df.units['station'] is None) assert (df.units['station_number'] is None) assert (df.units['time'] is None)
def test_high_alt_wyoming(): """Test Wyoming data that starts at pressure less than 925 hPa.""" df = WyomingUpperAir.request_data(datetime(2010, 12, 9, 12), 'BOI') assert(df['time'][0] == datetime(2010, 12, 9, 12)) assert(df['station'][0] == 'BOI') assert(df['station_number'][0] == 72681) assert(df['latitude'][0] == 43.56) assert(df['longitude'][0] == -116.21) assert(df['elevation'][0] == 874.0) assert_almost_equal(df['pressure'][2], 890.0, 2) assert_almost_equal(df['height'][2], 1133., 2) assert_almost_equal(df['temperature'][2], 5.4, 2) assert_almost_equal(df['dewpoint'][2], 3.9, 2) assert_almost_equal(df['u_wind'][2], -0.42, 2) assert_almost_equal(df['v_wind'][2], 5.99, 2) assert_almost_equal(df['speed'][2], 6.0, 1) assert_almost_equal(df['direction'][2], 176.0, 1) assert(df.units['pressure'] == 'hPa') assert(df.units['height'] == 'meter') assert(df.units['temperature'] == 'degC') assert(df.units['dewpoint'] == 'degC') assert(df.units['u_wind'] == 'knot') assert(df.units['v_wind'] == 'knot') assert(df.units['speed'] == 'knot') assert(df.units['direction'] == 'degrees') assert(df.units['latitude'] == 'degrees') assert(df.units['longitude'] == 'degrees') assert(df.units['elevation'] == 'meter') assert(df.units['station'] is None) assert(df.units['station_number'] is None) assert(df.units['time'] is None)
def test_wyoming_no_station(): """Test that we handle stations with no ID from the Wyoming archive.""" df = WyomingUpperAir.request_data(datetime(1976, 3, 4, 0), '72349') assert(df['time'][0] == datetime(1976, 3, 4)) assert(df['station'][0] == '') assert(df['station_number'][0] == 72349) assert(df['latitude'][0] == 36.88) assert(df['longitude'][0] == -93.9) assert(df['elevation'][0] == 438.0) assert_almost_equal(df['pressure'][5], 884.0, 2) assert_almost_equal(df['height'][5], 1140, 2) assert_almost_equal(df['temperature'][5], 14.6, 2) assert_almost_equal(df['dewpoint'][5], 12.8, 2) assert_almost_equal(df['u_wind'][5], -10.940, 2) assert_almost_equal(df['v_wind'][5], 25.774, 2) assert_almost_equal(df['speed'][5], 28.0, 1) assert_almost_equal(df['direction'][5], 157.0, 1) assert(df.units['pressure'] == 'hPa') assert(df.units['height'] == 'meter') assert(df.units['temperature'] == 'degC') assert(df.units['dewpoint'] == 'degC') assert(df.units['u_wind'] == 'knot') assert(df.units['v_wind'] == 'knot') assert(df.units['speed'] == 'knot') assert(df.units['direction'] == 'degrees') assert(df.units['latitude'] == 'degrees') assert(df.units['longitude'] == 'degrees') assert(df.units['elevation'] == 'meter') assert(df.units['station'] is None) assert(df.units['station_number'] is None) assert(df.units['time'] is None)
def test_wyoming(): """Test that we are properly parsing data from the Wyoming archive.""" df = WyomingUpperAir.request_data(datetime(1999, 5, 4, 0), 'OUN') assert(df['time'][0] == datetime(1999, 5, 4, 0)) assert(df['station'][0] == 'OUN') assert(df['station_number'][0] == 72357) assert(df['latitude'][0] == 35.18) assert(df['longitude'][0] == -97.44) assert(df['elevation'][0] == 345.0) assert_almost_equal(df['pressure'][5], 867.9, 2) assert_almost_equal(df['height'][5], 1219., 2) assert_almost_equal(df['temperature'][5], 17.4, 2) assert_almost_equal(df['dewpoint'][5], 14.3, 2) assert_almost_equal(df['u_wind'][5], 6.60, 2) assert_almost_equal(df['v_wind'][5], 37.42, 2) assert_almost_equal(df['speed'][5], 38.0, 1) assert_almost_equal(df['direction'][5], 190.0, 1) assert(df.units['pressure'] == 'hPa') assert(df.units['height'] == 'meter') assert(df.units['temperature'] == 'degC') assert(df.units['dewpoint'] == 'degC') assert(df.units['u_wind'] == 'knot') assert(df.units['v_wind'] == 'knot') assert(df.units['speed'] == 'knot') assert(df.units['direction'] == 'degrees') assert(df.units['latitude'] == 'degrees') assert(df.units['longitude'] == 'degrees') assert(df.units['elevation'] == 'meter') assert(df.units['station'] is None) assert(df.units['station_number'] is None) assert(df.units['time'] is None)
def getData(station_file, hh): """ This function will make use of Siphons Wyoming Upperair utility. Will pass the function a list of stations and data will be downloaded as pandas a pandas dataframe and the corresponding lats and lons will be placed into a dictionary along with the data. """ print('Getting station data...') station_data = pd.read_excel(station_file) stations, lats, lons = station_data['station_id'].values, station_data[ 'lat'].values, station_data['lon'].values stations = list(stations) date = datetime.utcnow() date = datetime(date.year, date.month, date.day, hh) data = {} #a dictionary for our data station_list = [] for station, lat, lon in zip(stations, lats, lons): try: df = WyomingUpperAir.request_data(date, station) data[station] = [df, lat, lon] station_list += [station] except: pass print('Data retrieved...') return data, station_list
def generate_plot(site, date=None): if date: request_time = datetime.strptime(date, '%Y%m%d%H') else: now = datetime.now(timezone.utc) - timedelta(hours=2) request_time = now.replace(hour=(now.hour // 12) * 12, minute=0, second=0) # Request the data and plot df = WyomingUpperAir.request_data(request_time, site) skewt = plot_skewt(df) # Add the timestamp for the data to the plot add_timestamp(skewt.ax, request_time, y=1.02, x=0, ha='left', fontsize='large') skewt.ax.set_title(site) # skewt.ax.figure.savefig(make_name(site, date, request_time)) bio = io.BytesIO() skewt.ax.figure.savefig(bio, format='svg') bio.seek(0) b64 = base64.b64encode(bio.read()) message = {} message['station_id'] = site message['sounding'] = b64 db.soundings.replace_one({'station_id': site}, message, upsert=True)
def return_ensemble(*, data_file_path, ens_params, coords, flags): sat_time = coords.sat_times[0] wind_time = return_wind_time(sat_time=sat_time, coords=coords) q = return_single_time(data_file_path, coords.sat_times_all, sat_time, [coords.sn_slice], [coords.we_slice], ['ci'])[0] if flags['radiosonde']: station = 'TUS' df = WyomingUpperAir.request_data(sat_time.date(), station) T = df['temperature'].values * units(df.units['temperature']) Td = df['dewpoint'].values * units(df.units['dewpoint']) u_wind = df['u_wind'].values * units(df.units['u_wind']) u_wind = u_wind.to(units.meter / units.second) v_wind = df['v_wind'].values * units(df.units['v_wind']) v_wind = v_wind.to(units.meter / units.second) rh = thermo.relative_humidity_from_dewpoint(T, Td) max_arg = np.argmax(rh) u_size = coords.we_stag_crop.size * coords.sn_crop.size v_size = coords.we_crop.size * coords.sn_stag_crop.size U = np.ones(u_size) * u_wind[max_arg] V = np.ones(v_size) * v_wind[max_arg] elif flags['opt_flow']: opt_flow_folder = os.path.split(data_file_path)[0] opt_flow_file = os.path.join(opt_flow_folder, 'data_opt_flow.nc') of_sat_time = coords.sat_times[1] U, V = return_single_time(opt_flow_file, coords.sat_times_all, of_sat_time, [coords.sn_slice, coords.sn_stag_slice], [coords.we_stag_slice, coords.we_slice], ['U_opt_flow', 'V_opt_flow']) time_step = (of_sat_time - sat_time).seconds U = U * (250 / time_step) V = V * (250 / time_step) U = U.clip(min=-50, max=50) V = V.clip(min=-50, max=50) else: U, V = return_single_time(data_file_path, coords.wind_times, wind_time, [coords.sn_slice, coords.sn_stag_slice], [coords.we_stag_slice, coords.we_slice], ['U', 'V']) U, V = smooth_winds(U, V) if flags['wrf_mean']: U = np.ones_like(U) * U.mean() V = np.ones_like(V) * V.mean() if flags['assim']: ensemble = ensemble_creator(q, U, V, CI_sigma=ens_params['ci_sigma'], wind_sigma=ens_params['winds_sigma'], ens_size=ens_params['ens_num']) else: ensemble = np.concatenate([U.ravel(), V.ravel(), q.ravel()])[:, None] shape = ensemble.shape ensemble = np.ma.compressed(ensemble).reshape(shape) return ensemble
def test_high_alt_wyoming(): """Test Wyoming data that starts at pressure less than 925 hPa.""" df = WyomingUpperAir.request_data(datetime(2010, 12, 9, 12), 'BOI') assert_almost_equal(df['pressure'][2], 890.0, 2) assert_almost_equal(df['height'][2], 1133., 2) assert_almost_equal(df['temperature'][2], 5.4, 2) assert_almost_equal(df['dewpoint'][2], 3.9, 2) assert_almost_equal(df['u_wind'][2], -0.42, 2) assert_almost_equal(df['v_wind'][2], 5.99, 2)
def get_sounding_data(date, station): df = WyomingUpperAir.request_data(date, station) p = df['pressure'].values * units(df.units['pressure']) T = df['temperature'].values * units(df.units['temperature']) Td = df['dewpoint'].values * units(df.units['dewpoint']) u = df['u_wind'].values * units(df.units['u_wind']) v = df['v_wind'].values * units(df.units['v_wind']) windspeed = df['speed'].values * units(df.units['speed']) return p, T, Td, u, v, windspeed
def WyomingSondes(date_time, station_id): df = WyomingUpperAir.request_data(date, station) #Extracting the variables and attaching units p = df['pressure'].values * units(df.units['pressure']) T = df['temperature'].values * units(df.units['temperature']) Td = df['dewpoint'].values * units(df.units['dewpoint']) u = df['u_wind'].values * units(df.units['u_wind']) v = df['v_wind'].values * units(df.units['v_wind']) heights = df['height'].values * units(df.units['height']) return p, T, Td, u, v, heights, df
def add_curves_Wyoming(ax, datetime, station, linewidth=1.0, LH_Tdepend=False): """ overlaying new curves of multiple soundings from Wyoming datasets date: using datetime module. ex. datetime(2018,06,06) station: station name. ex. 'MFL' Miami, Florida """ from siphon.simplewebservice.wyoming import WyomingUpperAir date = datetime station = station df = WyomingUpperAir.request_data(date, station) pressure = df['pressure'].values Temp = df['temperature'].values Temp_dew = df['dewpoint'].values altitude = df['height'].values q = mpcalc.mixing_ratio( mpcalc.saturation_vapor_pressure(Temp_dew * units('degC')), pressure * units('mbar')) q = mpcalc.specific_humidity_from_mixing_ratio(q) qs = mpcalc.mixing_ratio( mpcalc.saturation_vapor_pressure(Temp * units('degC')), pressure * units('mbar')) # specific energies if LH_Tdepend == False: mse = mpcalc.moist_static_energy(altitude * units('meter'), Temp * units('degC'), q) mse_s = mpcalc.moist_static_energy(altitude * units('meter'), Temp * units('degC'), qs) dse = mpcalc.dry_static_energy(altitude * units('meter'), Temp * units('degC')) else: # A short course in cloud physics, Roger and Yau (1989) Lvt = (2500.8 - 2.36 * T.magnitude + 0.0016 * T.magnitude**2 - 0.00006 * T.magnitude**3) * units( 'joule/gram') # latent heat of evaporation #Lf = 2834.1 - 0.29*T - 0.004*T**2 # latent heat of fusion mse = Cp_d * T + g * altitude + Lvt * q mse_s = Cp_d * T + g * altitude + Lvt * qs dse = mpcalc.dry_static_energy(altitude, T) # adding curves on the main axes ax.plot(dse.magnitude, pressure, 'k', linewidth=linewidth) ax.plot(mse.magnitude, pressure, 'b', linewidth=linewidth) ax.plot(mse_s.magnitude, pressure, 'r', linewidth=linewidth)
def test_wyoming(): """Test that we are properly parsing data from the wyoming archive.""" df = WyomingUpperAir.request_data(datetime(1999, 5, 4, 0), 'OUN') assert_almost_equal(df['pressure'][5], 867.9, 2) assert_almost_equal(df['height'][5], 1219., 2) assert_almost_equal(df['temperature'][5], 17.4, 2) assert_almost_equal(df['dewpoint'][5], 14.3, 2) assert_almost_equal(df['u_wind'][5], 6.60, 2) assert_almost_equal(df['v_wind'][5], 37.42, 2) assert_almost_equal(df['speed'][5], 38.0, 1) assert_almost_equal(df['direction'][5], 190.0, 1) assert (df.units['pressure'] == 'hPa') assert (df.units['height'] == 'meter') assert (df.units['temperature'] == 'degC') assert (df.units['dewpoint'] == 'degC') assert (df.units['u_wind'] == 'knot') assert (df.units['v_wind'] == 'knot') assert (df.units['speed'] == 'knot') assert (df.units['direction'] == 'degrees')
def test_wyoming(): """Test that we are properly parsing data from the wyoming archive.""" df = WyomingUpperAir.request_data(datetime(1999, 5, 4, 0), 'OUN') assert_almost_equal(df['pressure'][5], 867.9, 2) assert_almost_equal(df['height'][5], 1219., 2) assert_almost_equal(df['temperature'][5], 17.4, 2) assert_almost_equal(df['dewpoint'][5], 14.3, 2) assert_almost_equal(df['u_wind'][5], 6.60, 2) assert_almost_equal(df['v_wind'][5], 37.42, 2) assert_almost_equal(df['speed'][5], 38.0, 1) assert_almost_equal(df['direction'][5], 190.0, 1) assert(df.units['pressure'] == 'hPa') assert(df.units['height'] == 'meter') assert(df.units['temperature'] == 'degC') assert(df.units['dewpoint'] == 'degC') assert(df.units['u_wind'] == 'knot') assert(df.units['v_wind'] == 'knot') assert(df.units['speed'] == 'knot') assert(df.units['direction'] == 'degrees')
type=str) parser.add_argument('-f', '--filename', help='Image filename', type=str) args = parser.parse_args() if args.date: request_time = datetime.strptime(args.date, '%Y%m%d%H') else: # Figure out the most recent sounding, 00 or 12. Subtracting two hours # helps ensure that we choose a time with data available. now = datetime.utcnow() - timedelta(hours=2) request_time = now.replace(hour=(now.hour // 12) * 12, minute=0, second=0) # Request the data and plot df = WyomingUpperAir.request_data(request_time, args.site) skewt = plot_skewt(df) # Add the timestamp for the data to the plot add_timestamp(skewt.ax, request_time, y=1.02, x=0, ha='left', fontsize='large') skewt.ax.set_title(args.site) if args.show: plt.show() else: fname = args.filename if args.filename else make_name(
minute = '00' mdate = str(year) + str(month) + str(day) + '_' + hour + minute return mdate verification_time = get_verif_time(current_utc) model_init_time = model_init_time(current_utc) mdate = model_init_string(model_init_time) print(verification_time) print(model_init_time) print(mdate) for i in range(len(ideal_ua_station_ids)): try: df = WyomingUpperAir.request_data(verification_time, ideal_ua_station_ids[i]) lat = df['latitude'][0] lon = df['longitude'][0] p = df['pressure'] h5 = df[(df['pressure'] == 500)] z5 = h5['height'].values[0] obs_z5.append(z5) coord = (lat, lon) coords.append(coord) print(coord) ua_station_ids.append(ideal_ua_station_ids[i]) except: 'Data Unavailable For ' + ideal_ua_station_ids[i] def mkdir_p(mypath):
def plot_upper_air(station='11035', date=False): ''' ----------------------------- Default use of plot_upper_air: This will plot a SkewT sounding for station '11035' (Wien Hohe Warte) plot_upper_air(station='11035', date=False) ''' # sns.set(rc={'axes.facecolor':'#343837', 'figure.facecolor':'#343837', # 'grid.linestyle':'','axes.labelcolor':'#04d8b2','text.color':'#04d8b2', # 'xtick.color':'#04d8b2','ytick.color':'#04d8b2'}) # Get time in UTC station = str(station) if date is False: now = datetime.utcnow() # If morning then 0z sounding, otherwise 12z if now.hour < 12: hour = 0 else: hour = 12 date = datetime(now.year, now.month, now.day, hour) datestr = date.strftime('%Hz %Y-%m-%d') print('{}'.format(date)) else: year = int(input('Please specify the year: ')) month = int(input('Please specify the month: ')) day = int(input('Please specify the day: ')) hour = int(input('Please specify the hour: ')) if hour < 12: hour = 0 else: hour = 12 date = datetime(year, month, day, hour) datestr = date.strftime('%Hz %Y-%m-%d') print('You entered {}'.format(date)) # This requests the data 11035 is df = WyomingUpperAir.request_data(date, station) # Create single variables wih the right units p = df['pressure'].values * units.hPa T = df['temperature'].values * units.degC Td = df['dewpoint'].values * units.degC wind_speed = df['speed'].values * units.knots wind_dir = df['direction'].values * units.degrees wind_speed_6k = df['speed'][df.height <= 6000].values * units.knots wind_dir_6k = df['direction'][df.height <= 6000].values * units.degrees u, v = mpcalc.get_wind_components(wind_speed, wind_dir) u6, v6 = mpcalc.get_wind_components(wind_speed_6k, wind_dir_6k) # Calculate the LCL lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0]) print(lcl_pressure, lcl_temperature) # Calculate the parcel profile. parcel_prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC') cape, cin = mpcalc.cape_cin(p, T, Td, parcel_prof) ############################# # Create a new figure. The dimensions here give a good aspect ratio fig = plt.figure(figsize=(9, 9)) gs = gridspec.GridSpec(3, 3) skew = SkewT(fig, rotation=45, subplot=gs[:, :2]) # Plot the data using normal plotting functions, in this case using # log scaling in Y, as dictated by the typical meteorological plot skew.plot(p, T, 'r') skew.plot(p, Td, 'g') skew.plot_barbs(p, u, v) skew.ax.set_ylim(1000, 100) skew.ax.set_xlim(-45, 40) # Plot LCL as black dot skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black') # Plot the parcel profile as a black line skew.plot(p, parcel_prof, 'k', linewidth=2) # Shade areas of CAPE and CIN skew.shade_cin(p, T, parcel_prof) skew.shade_cape(p, T, parcel_prof) # Plot a zero degree isotherm skew.ax.axvline(0, color='c', linestyle='--', linewidth=2) skew.ax.set_title('Station: ' + str(station) + '\n' + datestr) # set title skew.ax.set_xlabel('Temperature (C)') skew.ax.set_ylabel('Pressure (hPa)') # Add the relevant special lines skew.plot_dry_adiabats(linewidth=0.7) skew.plot_moist_adiabats(linewidth=0.7) skew.plot_mixing_lines(linewidth=0.7) # Create a hodograph # Create an inset axes object that is 40% width and height of the # figure and put it in the upper right hand corner. # ax_hod = inset_axes(skew.ax, '40%', '40%', loc=1) ax = fig.add_subplot(gs[0, -1]) h = Hodograph(ax, component_range=60.) h.add_grid(increment=20) # Plot a line colored by windspeed h.plot_colormapped(u6, v6, wind_speed_6k) # add another subplot for the text of the indices # ax_t = fig.add_subplot(gs[1:,2]) skew2 = SkewT(fig, rotation=0, subplot=gs[1:, 2]) skew2.plot(p, T, 'r') skew2.plot(p, Td, 'g') # skew2.plot_barbs(p, u, v) skew2.ax.set_ylim(1000, 700) skew2.ax.set_xlim(-30, 10) # Show the plot plt.show() return cape
# Set time using a datetime object and station as variables # dt = datetime(2016, 10, 26, 12) station = 'MPX' ###################################################################### # Grab Remote Data # ---------------- # # This requires an internet connection to access the sounding data from a # remote server at the University of Wyoming. # # Read remote sounding data based on time (dt) and station df = WyomingUpperAir.request_data(dt, station) # Create dictionary of united arrays data = pandas_dataframe_to_unit_arrays(df) ###################################################################### # Isolate variables and attach units # # Isolate united arrays from dictionary to individual variables p = data['pressure'] T = data['temperature'] Td = data['dewpoint'] u = data['u_wind'] v = data['v_wind']
import matplotlib.pyplot as plt import numpy as np import pandas as pd import math from datetime import * import metpy.calc as mpcalc #pip install metpy from metpy.plots import add_metpy_logo, skewt from metpy.units import units from siphon.simplewebservice.wyoming import WyomingUpperAir #pip install siphon date = datetime(2020, 9, 1, 06) num_days = 4 data = pd.DataFrame() for i in range(0, num_days): station = '78988' try: data = WyomingUpperAir.request_data(date, station) print(data) except: print("No existen datos") data.to_csv( f'/home/dirac/Dropbox/2020/WRFDA_FAC_EAFIT/Sondas/Descarga_Sondas/new_download/{station}{date}.csv', index=True) date = date + timedelta(days=1)
import numpy as np import matplotlib.pyplot as plt from siphon.simplewebservice.wyoming import WyomingUpperAir from metpy.plots import SkewT from datetime import datetime, timedelta from metpy.units import units import metpy.calc as metcalc dataset = WyomingUpperAir.request_data(datetime(2018, 6, 27, 0), 'ILX') #get_ipython().run_line_magic('matplotlib', 'inline') p = dataset['pressure'].values * units(dataset.units['pressure']) #ip100 = np.where(p.magnitude==100.)[0][0]+1 #p = p[:ip100] T = dataset['temperature'].values * units(dataset.units['temperature']) #T = T[:ip100] Td = dataset['dewpoint'].values * units(dataset.units['dewpoint']) #Td = Td[:ip100] u = dataset['u_wind'].values * units(dataset.units['u_wind']) #u = u[:ip100] v = dataset['v_wind'].values * units(dataset.units['v_wind']) #v = v[:ip100] fig = plt.figure(figsize=(9, 9)) skew = SkewT(fig) skew.plot(p, T, 'r') skew.plot(p, Td, 'g') skew.plot_barbs(p[:-1:2], u[:-1:2], v[:-1:2]) skew.plot_dry_adiabats() skew.plot_moist_adiabats()
def upper_air(config, station_id, sounding_station_id, date, use_nan_sounding=False, use_existing=True, save=True): """ Retrieves upper-air data and interpolates to pressure levels. If use_nan_sounding is True, then if a retrieval error occurs, a blank sounding will be returned instead of an error. :param config: :param station_id: station ID of surface station used :param sounding_station_id: station ID of sounding station to use :param date: datetime :param use_nan_sounding: bool: if True, use sounding of NaNs instead of raising an error :param use_existing: bool: preferentially use existing soundings in sounding_data_dir :param save: bool: if True, save processed soundings to sounding_data_dir :return: """ variables = ['height', 'temperature', 'dewpoint', 'u_wind', 'v_wind'] # Define levels for interpolation: same as model data, except omitting lowest_p_level plevs = [600, 750, 850, 925] pres_interp = np.array([p for p in plevs if p <= config['lowest_p_level']]) # Try retrieving the sounding, first checking for existing if config['verbose']: print('upper_air: retrieving sounding for %s' % datetime.strftime(date, '%Y%m%d%H')) nan_sounding = False retrieve_sounding = False sndg_data_dir = config['Obs']['sounding_data_dir'] if not (os.path.isdir(sndg_data_dir)): os.makedirs(sndg_data_dir) sndg_file = '%s/%s_SNDG_%s.pkl' % (sndg_data_dir, station_id, datetime.strftime(date, '%Y%m%d%H')) if use_existing: try: data = read_pkl(sndg_file) if config['verbose']: print(' Read from file.') except: retrieve_sounding = True else: retrieve_sounding = True if retrieve_sounding: try: dset = WyomingUpperAir.request_data( date, config['Obs']['sounding_station_id']) except: # Try again try: dset = WyomingUpperAir.request_data( date, config['Obs']['sounding_station_id']) except: if use_nan_sounding: if config['verbose']: print( 'upper_air: warning: unable to retrieve sounding; using nan.' ) nan_sounding = True else: raise ValueError('error retrieving sounding for %s' % date) # Retrieve pressure for interpolation to fixed levels if not nan_sounding: pressure = dset.variables['pressure'] pres = np.array([p.magnitude for p in list(pressure)]) # units are hPa # Get variables and interpolate; add to dictionary data = OrderedDict() for var in variables: if not nan_sounding: var_data = dset.variables[var] var_array = np.array([v.magnitude for v in list(var_data)]) var_interp = interp(pres_interp, pres, var_array) data[var] = var_interp.tolist() else: data[var] = [np.nan] * len(pres_interp) # Save if save and not nan_sounding: with open(sndg_file, 'wb') as handle: pickle.dump(data, handle, protocol=2) return data
def test_no_data_wyoming(): """Test Wyoming data when no data are available.""" with pytest.raises(ValueError): WyomingUpperAir.request_data(datetime(2010, 12, 9, 1), 'BOI')
def get_sounding_data(date, region, station): return WyomingUpperAir.request_data(date, station, region=region)
def get_sounding(ts, site, fill_value=None): requester = WyomingUpperAir() df = requester.request_data(time=pd.Timestamp(ts), site_id=site) return df.replace({np.nan: fill_value, np.inf: fill_value})
""" from datetime import datetime from metpy.units import units from siphon.simplewebservice.wyoming import WyomingUpperAir #################################################### # Create a datetime object for the sounding and string of the station identifier. date = datetime(2017, 9, 10, 6) station = 'MFL' #################################################### # Make the request (a pandas dataframe is returned). df = WyomingUpperAir.request_data(date, station) #################################################### # Inspect data columns in the dataframe. print(df.columns) #################################################### # Pull out a specific column of data. print(df['pressure']) #################################################### # Units are stored in a dictionary with the variable name as the key in the `units` attribute # of the dataframe. print(df.units) ####################################################
# Import the Wyoming simple web service upper air object from siphon.simplewebservice.wyoming import WyomingUpperAir # Create the datetime and station variables you'll need request_time = datetime(2011, 4, 14, 18) station = 'OUN' # Make the request for the data df = WyomingUpperAir.request_data(request_time, station) # Attach units to the data sounding = pandas_dataframe_to_unit_arrays(df)
def grabSounding(date, station): df = WyomingUpperAir.request_data(date, station) pFull = df["pressure"].values * units(df.units["pressure"]) TFull = df["temperature"].values * units(df.units["temperature"]) return pFull, TFull