def wyoming_pandas_to_dict(df): # extract metadata metadata = {k: v for d in df._metadata for k, v in d.items()} sounding_time = metadata['Observation time'] date_sounding = datetime.datetime( int('20' + sounding_time[0:2]), int(sounding_time[2:4]), int(sounding_time[4:6]), int(sounding_time[7:9], int(sounding_time[9:11]))) # build dictionary sounding = {} sounding['dimlabel'] = ['range'] sounding['range'] = df['range'].values sounding['speed'] = (df['speed'].values * units.units('knots')).to_base_units().magnitude sounding['time'] = h.dt_to_ts(date_sounding) sounding['u_wind'] = (df['u_wind'].values * units.units('knots')).to_base_units().magnitude sounding['v_wind'] = (df['v_wind'].values * units.units('knots')).to_base_units().magnitude sounding['dewpoint'] = df['dewpoint'] sounding['direction'] = df['direction'] sounding['pressure'] = df['pressure'] sounding['temperature'] = df['temperature'] return sounding
def retfunc(f, time_interval, *further_intervals): """ function that converts the txt file to larda data container Args: f: time_interval: Returns: larda data container with sounding data """ import csv import datetime logger.debug("filename at reader {}".format(f)) with open(f) as f: reader = csv.reader(f, delimiter='\t') headers = next(reader, None) var_index = [ i for i, j in enumerate(headers) if j == paraminfo['variable_name'] ] assert ( len(var_index) == 1 ), "mismatch between headers in file and variable name in toml" rg_index = [ i for i, j in enumerate(headers) if j == paraminfo['range_variable'] ] assert ( len(rg_index) == 1 ), "mismatch between headers in file and range variable name in toml" data = {} data['dimlabel'] = ['time', 'range'] data['ts'] = np.array([ h.dt_to_ts( datetime.datetime.strptime( f.name.split('/')[-1][0:11], '%Y%m%d_%H')) ]) data['var'] = [] data['rg'] = [] for row in reader: try: data['var'].append(float(row[var_index[0]])) except ValueError: # empty line cannot be converted to float data['var'].append(np.nan) data['rg'].append(float(row[rg_index[0]])) data['var'] = np.array(data['var'])[np.newaxis, :] data['rg'] = np.array(data['rg']) data['mask'] = np.isnan(data['var']) data['name'] = paraminfo['paramkey'] data['system'] = paraminfo['system'] data['var_lims'] = paraminfo['var_lims'] data[ 'colormap'] = 'jet' if not 'colormap' in paraminfo else paraminfo[ 'colormap'] data['rg_unit'] = paraminfo['rg_unit'] data['var_unit'] = paraminfo['var_unit'] data['paraminfo'] = paraminfo data['filename'] = f.name return data
def get_time_slicer(ts, f, time_interval): """get time slicer from the time_interval Following options are available 1. time_interval with [ts_begin, ts_end] 2. only one timestamp is selected and the found right one would be beyond the ts range -> argnearest instead searchsorted 3. only one is timestamp """ # select first timestamp right of begin (not left if nearer as above) #print(f'start time {h.ts_to_dt(ts[0])}') it_b = 0 if ts.shape[0] == 1 else np.searchsorted( ts, h.dt_to_ts(time_interval[0]), side='right') if len(time_interval) == 2: it_e = h.argnearest(ts, h.dt_to_ts(time_interval[1])) if it_b == ts.shape[0]: it_b = it_b - 1 valid_step = 3 * np.median(np.diff(ts)) if ts[it_e] < h.dt_to_ts( time_interval[0]) - valid_step or ts[it_b] < h.dt_to_ts( time_interval[0]): # second condition is to ensure that no timestamp before # the selected interval is choosen # (problem with limrad after change of sampling frequency) str = 'found last profile of file {}\n at ts[it_e] {} too far ({}s) from {}\n'.format( f, h.ts_to_dt(ts[it_e]), valid_step, time_interval[0]) \ + 'or begin too early {} < {}\n returning None'.format(h.ts_to_dt(ts[it_b]), time_interval[0]) logger.warning(str) return None it_e = it_e + 1 if not it_e == ts.shape[0] - 1 else None slicer = [slice(it_b, it_e)] elif it_b == ts.shape[0]: # only one timestamp is selected # and the found right one would be beyond the ts range it_b = h.argnearest(ts, h.dt_to_ts(time_interval[0])) slicer = [slice(it_b, it_b + 1)] else: slicer = [slice(it_b, it_b + 1)] return slicer
def collect(self, param, time_interval, *further_intervals, **kwargs): """collect the data from a parameter for the given intervals Args: param (str) identifying the parameter time_interval: list of begin and end datetime *further_intervals: range, velocity, ... """ resp_format = 'msgpack' interval = ["-".join([str(h.dt_to_ts(dt)) for dt in time_interval])] interval += ["-".join([str(i) for i in pair]) for pair in further_intervals] stream = True if resp_format is "msgpack" else False params = {"interval": ','.join(interval), 'rformat': resp_format} params.update(kwargs) resp = requests.get(self.uri + '/api/{}/{}/{}'.format(self.camp_name, self.system, param), params=params, stream=stream) logger.debug("fetching data from: {}".format(resp.url)) if resp_format is "msgpack": block_size = 1024 pbar = tqdm(unit="B", total=(int(resp.headers.get('content-length', 0))//block_size)*block_size, unit_divisor=1024, unit_scale=True) content = bytearray() for data in resp.iter_content(block_size): content.extend(data) pbar.update(len(data)) if resp.status_code != 200: if resp_format is "msgpack": print("Error at Backend") print(content.decode("unicode_escape")) else: print(resp.json()) raise ConnectionError("bad status code of response {}".format(resp.status_code)) starttime = time.time() # if resp_format == 'bin': # data_container = cbor2.loads(resp.content) if resp_format == 'msgpack': logger.info("msgpack version {}".format(msgpack.version)) if msgpack.version[0] < 1: data_container = msgpack.loads(content, encoding='utf-8') else: data_container = msgpack.loads(content, strict_map_key=False) elif resp_format == 'json': data_container = resp.json() #print("{:5.3f}s decode data".format(time.time() - starttime)) starttime = time.time() for k in ['ts', 'rg', 'vel', 'var', 'mask']: if k in data_container and type(data_container[k]) == list: data_container[k] = np.array(data_container[k]) logger.info("loaded data container from remote: {}".format(data_container.keys())) #print("{:5.3f}s converted to np arrays".format(time.time() - starttime)) return data_container
def plot_range_spectrogram(ZSpec, dt, **font_settings): unix_0 = np.float64(h.dt_to_ts(dt)) Z = ZSpec.sel(ts=slice(unix_0, unix_0 + 30.0), rg=slice(font_settings['range_interval'][0], font_settings['range_interval'][1])) z_var = Z.values.copy() #z_var = np.ma.masked_less_equal(Z.values, 0.0) z_var = np.squeeze(z_var) x_var = np.linspace(0, 6 * 256, num=6 * 256) z_var = z_var.reshape((-1, 6 * 256), order='F') fig, ax = plt.subplots(1, figsize=_FIG_SIZE) surf = ax.pcolormesh(x_var, Z.rg, z_var[:, :], vmin=dBZ_lim[0], vmax=dBZ_lim[1], cmap='jet') #ax.set_xlim(vel_lim) ax.set_xlabel(xlabel=r"Doppler velocity bins [-]") ax.set_ylim(font_settings['range_interval']) ax.set_ylabel("range [m]", **{}) ax.grid() # Add a color bar which maps values to colors. cbar = fig.colorbar( surf, fraction=0.2, shrink=1., pad=0.01, orientation='vertical', ) cbar.ax.tick_params(axis='both', which='major', labelsize=12, width=2, length=4) cbar.ax.tick_params(axis='both', which='minor', width=2, length=3) cbar.ax.minorticks_on() cbar.ax.set_ylabel("signal normalized", **{}) plt.tight_layout()
def t_r(f, time_interval, *further_intervals): """function that converts the trace netCDF to the data container """ logger.debug("filename at reader {}".format(f)) with netCDF4.Dataset(f, 'r') as ncD: times = ncD.variables[paraminfo['time_variable']][:].astype( np.float64) timeconverter, _ = h.get_converter_array( paraminfo['time_conversion'], ncD=ncD) ts = timeconverter(times) #print('timestamps ', ts[:5]) # setup slice to load base on time_interval it_b = h.argnearest(ts, h.dt_to_ts(time_interval[0])) if len(time_interval) == 2: it_e = h.argnearest(ts, h.dt_to_ts(time_interval[1])) if ts[it_e] < h.dt_to_ts( time_interval[0]) - 3 * np.median(np.diff(ts)): logger.warning( 'last profile of file {}\n at {} too far from {}'. format(f, h.ts_to_dt(ts[it_e]), time_interval[0])) return None it_e = it_e + 1 if not it_e == ts.shape[0] - 1 else None slicer = [slice(it_b, it_e)] else: slicer = [slice(it_b, it_b + 1)] print(slicer) range_interval = further_intervals[0] ranges = ncD.variables[paraminfo['range_variable']] logger.debug('loader range conversion {}'.format( paraminfo['range_conversion'])) rangeconverter, _ = h.get_converter_array( paraminfo['range_conversion'], altitude=paraminfo['altitude']) ir_b = h.argnearest(rangeconverter(ranges[:]), range_interval[0]) if len(range_interval) == 2: if not range_interval[1] == 'max': ir_e = h.argnearest(rangeconverter(ranges[:]), range_interval[1]) ir_e = ir_e + 1 if not ir_e == ranges.shape[0] - 1 else None else: ir_e = None slicer.append(slice(ir_b, ir_e)) else: slicer.append(slice(ir_b, ir_b + 1)) varconverter, maskconverter = h.get_converter_array( paraminfo['var_conversion']) its = np.arange(ts.shape[0])[tuple(slicer)[0]] irs = np.arange(ranges.shape[0])[tuple(slicer)[1]] var = np.empty((its.shape[0], irs.shape[0])) mask = np.empty((its.shape[0], irs.shape[0])) mask[:] = False var = ncD.variables[paraminfo['variable_name']][ tuple(slicer)[0], tuple(slicer)[1], :] data = {} data['dimlabel'] = ['time', 'range', 'cat'] data["filename"] = f data["paraminfo"] = paraminfo data['ts'] = ts[tuple(slicer)[0]] data['system'] = paraminfo['system'] data['name'] = paraminfo['paramkey'] data['colormap'] = paraminfo['colormap'] if 'meta' in paraminfo: data['meta'] = NcReader.get_meta_from_nc( ncD, paraminfo['meta'], paraminfo['variable_name']) variable = ncD.variables[paraminfo['variable_name']] var_definition = ast.literal_eval( variable.getncattr(paraminfo['identifier_var_def'])) if var_definition[1] == "forrest": var_definition[1] = "forest" data['var_definition'] = var_definition data['rg'] = rangeconverter(ranges[tuple(slicer)[1]]) data['rg_unit'] = NcReader.get_var_attr_from_nc( "identifier_rg_unit", paraminfo, ranges) logger.debug('shapes {} {} {}'.format(ts.shape, ranges.shape, var.shape)) data['var_unit'] = NcReader.get_var_attr_from_nc( "identifier_var_unit", paraminfo, var) data['var_lims'] = [float(e) for e in \ NcReader.get_var_attr_from_nc("identifier_var_lims", paraminfo, var)] data['var'] = varconverter(var) data['mask'] = maskconverter(mask) return data
def pt_ret(f, time_interval, *further_intervals): """function that converts the peakTree netCDF to the data container """ logger.debug("filename at reader {}".format(f)) with netCDF4.Dataset(f, 'r') as ncD: times = ncD.variables[paraminfo['time_variable']][:].astype(np.float64) if 'time_millisec_variable' in paraminfo.keys() and \ paraminfo['time_millisec_variable'] in ncD.variables: subsec = ncD.variables[paraminfo['time_millisec_variable']][:]/1.0e3 times += subsec if 'time_microsec_variable' in paraminfo.keys() and \ paraminfo['time_microsec_variable'] in ncD.variables: subsec = ncD.variables[paraminfo['time_microsec_variable']][:]/1.0e6 times += subsec timeconverter, _ = h.get_converter_array( paraminfo['time_conversion'], ncD=ncD) ts = timeconverter(times) #print('timestamps ', ts[:5]) # setup slice to load base on time_interval it_b = h.argnearest(ts, h.dt_to_ts(time_interval[0])) if len(time_interval) == 2: it_e = h.argnearest(ts, h.dt_to_ts(time_interval[1])) if ts[it_e] < h.dt_to_ts(time_interval[0])-3*np.median(np.diff(ts)): logger.warning( 'last profile of file {}\n at {} too far from {}'.format( f, h.ts_to_dt(ts[it_e]), time_interval[0])) return None it_e = it_e+1 if not it_e == ts.shape[0]-1 else None slicer = [slice(it_b, it_e)] else: slicer = [slice(it_b, it_b+1)] print(slicer) if paraminfo['ncreader'] == 'peakTree': range_tg = True range_interval = further_intervals[0] ranges = ncD.variables[paraminfo['range_variable']] logger.debug('loader range conversion {}'.format(paraminfo['range_conversion'])) rangeconverter, _ = h.get_converter_array( paraminfo['range_conversion'], altitude=paraminfo['altitude']) ir_b = h.argnearest(rangeconverter(ranges[:]), range_interval[0]) if len(range_interval) == 2: if not range_interval[1] == 'max': ir_e = h.argnearest(rangeconverter(ranges[:]), range_interval[1]) ir_e = ir_e+1 if not ir_e == ranges.shape[0]-1 else None else: ir_e = None slicer.append(slice(ir_b, ir_e)) else: slicer.append(slice(ir_b, ir_b+1)) varconverter, maskconverter = h.get_converter_array( paraminfo['var_conversion']) its = np.arange(ts.shape[0])[tuple(slicer)[0]] irs = np.arange(ranges.shape[0])[tuple(slicer)[1]] var = np.empty((its.shape[0], irs.shape[0]), dtype=object) mask = np.empty((its.shape[0], irs.shape[0]), dtype=bool) mask[:] = True param_list = [ ncD.variables['parent'][tuple(slicer)[0],tuple(slicer)[1],:], #0 ncD.variables['Z'][tuple(slicer)[0],tuple(slicer)[1],:], #1 ncD.variables['v'][tuple(slicer)[0],tuple(slicer)[1],:], #2 ncD.variables['width'][tuple(slicer)[0],tuple(slicer)[1],:], #3 ncD.variables['skew'][tuple(slicer)[0],tuple(slicer)[1],:], #4 ncD.variables['threshold'][tuple(slicer)[0],tuple(slicer)[1],:], #5 ncD.variables['prominence'][tuple(slicer)[0],tuple(slicer)[1],:], #6 ncD.variables['bound_l'][tuple(slicer)[0],tuple(slicer)[1],:], #7 ncD.variables['bound_r'][tuple(slicer)[0],tuple(slicer)[1],:] #8 ] if 'LDR' in ncD.variables.keys(): ldr_avail = True param_list.append(ncD.variables['LDR'][tuple(slicer)[0],tuple(slicer)[1],:]) #9 param_list.append(ncD.variables['ldrmax'][tuple(slicer)[0],tuple(slicer)[1],:]) #10 else: ldr_avail = False data = np.stack(tuple(param_list), axis=3) print(data.shape) if fastbuilder: var, mask = peakTree_fastbuilder.array_to_tree_c(data.astype(float), ldr_avail) else: var, mask = array_to_tree_py(data, ldr_avail) data = {} data['dimlabel'] = ['time', 'range', 'dict'] data["filename"] = f data["paraminfo"] = paraminfo data['ts'] = ts[tuple(slicer)[0]] data['system'] = paraminfo['system'] data['name'] = paraminfo['paramkey'] data['colormap'] = paraminfo['colormap'] data['rg'] = rangeconverter(ranges[tuple(slicer)[1]]) data['rg_unit'] = NcReader.get_var_attr_from_nc("identifier_rg_unit", paraminfo, ranges) logger.debug('shapes {} {} {}'.format(ts.shape, ranges.shape, var.shape)) logger.debug('shapes {} {}'.format(ts.shape, var.shape)) data['var_unit'] = NcReader.get_var_attr_from_nc("identifier_var_unit", paraminfo, var) data['var_lims'] = [float(e) for e in \ NcReader.get_var_attr_from_nc("identifier_var_lims", paraminfo, var)] data['var'] = varconverter(var) data['mask'] = maskconverter(mask) return data
def retfunc(f, time_interval, range_interval): """function that converts the netCDF to the larda-data-format """ logger.debug("filename at reader {}".format(f)) with netCDF4.Dataset(f, 'r') as ncD: ranges = ncD.variables[paraminfo['range_variable']] times = ncD.variables[paraminfo['time_variable']][:].astype( np.float64) locator_mask = ncD.variables[paraminfo['mask_var']][:].astype( np.int) if 'time_millisec_variable' in paraminfo.keys() and \ paraminfo['time_millisec_variable'] in ncD.variables: subsec = ncD.variables[ paraminfo['time_millisec_variable']][:] / 1.0e3 times += subsec if 'time_microsec_variable' in paraminfo.keys() and \ paraminfo['time_microsec_variable'] in ncD.variables: subsec = ncD.variables[ paraminfo['time_microsec_variable']][:] / 1.0e6 times += subsec if 'base_time_variable' in paraminfo.keys() and \ paraminfo['base_time_variable'] in ncD.variables: basetime = ncD.variables[ paraminfo['base_time_variable']][:].astype(np.float64) times += basetime timeconverter, _ = h.get_converter_array( paraminfo['time_conversion'], ncD=ncD) ts = timeconverter(times) it_b = np.searchsorted(ts, h.dt_to_ts(time_interval[0]), side='right') if len(time_interval) == 2: it_e = h.argnearest(ts, h.dt_to_ts(time_interval[1])) if it_b == ts.shape[0]: it_b = it_b - 1 if ts[it_e] < h.dt_to_ts(time_interval[0]) - 3 * np.median(np.diff(ts)) \ or ts[it_b] < h.dt_to_ts(time_interval[0]): # second condition is to ensure that no timestamp before # the selected interval is chosen # (problem with limrad after change of sampling frequency) logger.warning( 'last profile of file {}\n at {} too far from {}'. format(f, h.ts_to_dt(ts[it_e]), time_interval[0])) return None it_e = it_e + 1 if not it_e == ts.shape[0] - 1 else None slicer = [slice(it_b, it_e)] elif it_b == ts.shape[0]: # only one timestamp is selected # and the found right one would be beyond the ts range it_b = h.argnearest(ts, h.dt_to_ts(time_interval[0])) slicer = [slice(it_b, it_b + 1)] else: slicer = [slice(it_b, it_b + 1)] rangeconverter, _ = h.get_converter_array( paraminfo['range_conversion']) varconverter, _ = h.get_converter_array( paraminfo['var_conversion']) ir_b = h.argnearest(rangeconverter(ranges[:]), range_interval[0]) if len(range_interval) == 2: if not range_interval[1] == 'max': ir_e = h.argnearest(rangeconverter(ranges[:]), range_interval[1]) ir_e = ir_e + 1 if not ir_e == ranges.shape[0] - 1 else None else: ir_e = None slicer.append(slice(ir_b, ir_e)) else: slicer.append(slice(ir_b, ir_b + 1)) range_out = rangeconverter(ranges[tuple(slicer)[1]]) cal = getattr(ncD, paraminfo['cal_const']) var = ncD.variables[paraminfo['variable_name']][:].astype( np.float64) var = var[locator_mask] vel = ncD.variables[paraminfo['vel_variable']][:].astype( np.float64) # print('var dict ',ch1var.__dict__) # print('shapes ', ts.shape, ch1range.shape, ch1var.shape) # print("time indices ", it_b, it_e) data = {} data['dimlabel'] = ['time', 'range', 'vel'] data["filename"] = f data["paraminfo"] = paraminfo data['ts'] = ts[tuple(slicer)[0]] data['rg'] = range_out data['system'] = paraminfo['system'] data['name'] = paraminfo['paramkey'] data['colormap'] = paraminfo['colormap'] # also experimental: vis_varconverter if 'plot_varconverter' in paraminfo and paraminfo[ 'plot_varconverter'] != 'none': data['plot_varconverter'] = paraminfo['plot_varconverter'] else: data['plot_varconverter'] = '' data['rg_unit'] = get_var_attr_from_nc("identifier_rg_unit", paraminfo, ranges) #data['var_unit'] = get_var_attr_from_nc("identifier_var_unit", # paraminfo, var) data['var_unit'] = 'dBZ m-1 s' data['var_lims'] = [float(e) for e in \ get_var_attr_from_nc("identifier_var_lims", paraminfo, var)] data['vel'] = vel if "identifier_fill_value" in paraminfo.keys( ) and not "fill_value" in paraminfo.keys(): fill_value = var.getncattr(paraminfo['identifier_fill_value']) data['mask'] = (var[tuple(slicer)].data == fill_value) elif "fill_value" in paraminfo.keys(): fill_value = paraminfo["fill_value"] data['mask'] = np.isclose(var[tuple(slicer)], fill_value) elif "mask_var" in paraminfo.keys(): # combine locator mask and mask of infinite values mask = locator_mask.mask[tuple(slicer)] data["mask"] = np.logical_or( ~np.isfinite(var[tuple(slicer)].data), np.repeat(mask[:, :, np.newaxis], len(data['vel']), axis=2)) else: data['mask'] = ~np.isfinite(var[tuple(slicer)].data) if isinstance(times, np.ma.MaskedArray): var = varconverter(var[tuple(slicer)].data) else: var = varconverter(var[tuple(slicer)]) var2 = h.z2lin(var) * h.z2lin(float( cal[:-3])) * (range_out**2)[np.newaxis, :, np.newaxis] data['var'] = var2 return data
def get_explorer_link(campaign, time_interval, range_interval, params): s = "http://larda.tropos.de/larda3/explorer/{}?interval={}-{}%2C{}-{}¶ms={}".format( campaign, h.dt_to_ts(time_interval[0]), h.dt_to_ts(time_interval[1]), *range_interval, ",".join(params)) return s
def wrapper(mat_data, **kwargs): """Wrap a larda container around .mat file data to use the pyLARDA.Transformations library . Args: mat_data (.mat) : Matlab .mat file datad Kwargs: var_name (string) : variable name in .mat file var_unit (string) : unit of the variable var_lims (list) : boundaries of the variable (for plotting) Return: container (dict) : sliced container """ var_name = kwargs['var_name'] if 'var_name' in kwargs else '' var_unit = kwargs['var_unit'] if 'var_unit' in kwargs else '' assert isinstance(var_name, str) and len(var_name) > 0, 'Error utility.wrapper! Check var_name argument!' time_var, range_var, system = '', '', '' if 'ts_class_time' in mat_data.keys(): # set variable lists for cloudnet classification dict time_var, range_var = 'ts_class_time', 'h_class' system = 'clouetnet-classification' elif 'ts_cat_time' in mat_data.keys(): # set variable lists for cloudnet categorization dict time_var, range_var = 'ts_cat_time', 'h_cat' system = 'cloudnet-categorization' elif 'ts_polly_time' in mat_data.keys(): # set variable lists for PollyXT dict time_var, range_var = 'ts_polly_time', 'h_class' elif 'ts_NN_time' in mat_data.keys(): # set variable lists for predicted Ed Luke ANN prediction dict time_var, range_var = 'ts_NN_time', 'h_class' elif 'ts_sp_time' in mat_data.keys(): # set variable lists for Mira Doppler radar dict time_var, range_var = 'ts_sp_time', 'h_class' system = 'mira' elif 'ts_rs_time' in mat_data.keys(): # set variable lists for radiosonde dict time_var, range_var = 'ts_rs_time', 'h_rs' system = 'radio-sonde' if var_name == 'target_class_ts': name = 'CLASS' colormap = 'cloudnet_target_new' elif var_name == 'combi_liq_mask': system = 'ann-vs-cloudnet-cloud-droplet-mask' name = 'CLASS' colormap = 'four_colors' elif var_name == 'ldr_cc_ts': system = 'cloudnet-categorization' name = var_name colormap = 'LDR' else: name = var_name colormap = 'cloudnet_jet' dt_list = [datenum2datetime(dn) for dn in mat_data[time_var]] time = [h.dt_to_ts(dt) for dt in dt_list] if var_name == 'bsc_NN_ts' and 'var_converter' in kwargs and kwargs['var_converter'] == 'log': var = np.ma.masked_invalid(mat_data[var_name].T) var = np.ma.power(10.0, var) else: var = mat_data[var_name].T var_lims = kwargs['var_lims'] if 'var_lims' in kwargs else [np.nanmin(var), np.nanmax(var)] if len(var.shape) == 2: dimlabel = ['time', 'range'] elif len(var.shape) == 1: dimlabel = ['time'] else: raise ValueError('Variable must be 1D or 2D!') larda_container = {'dimlabel': dimlabel, 'filename': 'accept .mat file', 'paraminfo': {}, 'rg_unit': 'm', 'colormap': colormap, 'var_unit': var_unit, 'var_lims': var_lims, 'system': system, 'name': name, 'rg': np.array(mat_data[range_var]), 'ts': np.array(time), 'mask': np.isnan(var), 'var': var} return larda_container
day = 18 HH0 = 9 MM0 = 24 HH1 = 9 MM1 = 25 begin_dt = datetime.datetime(year, month, day, HH0, MM0, 0) end_dt = datetime.datetime(year, month, day, HH1, MM1, 0) plot_range = [0, 12000] MIRA_Zspec = larda.read("MIRA", "Zspec", [begin_dt, end_dt], [0, 'max']) LIMRAD_Zspec = larda.read("LIMRAD94", "VSpec", [begin_dt, end_dt], [0, 'max']) print("slice time-range spectrogram") interval = { 'time': [h.dt_to_ts(begin_dt), h.dt_to_ts(end_dt)], 'range': [6300, 6400] } spectrogram_LIMRAD = pyLARDA.Transformations.slice_container(LIMRAD_Zspec, value=interval) spectrogram_MIRA = pyLARDA.Transformations.slice_container(MIRA_Zspec, value=interval) name = 'plots/PNG/spectra_limrad_mira_' fig, ax = pyLARDA.Transformations.plot_spectra(spectrogram_LIMRAD, spectrogram_MIRA, z_converter='lin2z', save=name)