def ex_gmag(plot=True): """Demonstrate how to use gmag functions.""" # Delete any existing pytplot variables pytplot.del_data() # Define a time rage as a list trange = ['2015-12-31', '2015-12-31'] # Get a list of EPO gmag stations sites = pyspedas.themis.ground.gmag.gmag_list('epo') # Download gmag files and load data into pytplot variables pyspedas.themis.gmag(sites=sites, trange=trange) # Get a list of loaded sites sites_loaded = pyspedas.tnames() # Subtract mean values pyspedas.subtract_average(sites_loaded, '') # Download AE index data # pyspedas.load_data('gmag', time_list, ['idx'], '', '') pyspedas.themis.gmag(sites='idx', trange=trange) # Plot sites_loaded = pytplot.tplot_names() pytplot.tplot_options('title', 'EPO GMAG 2015-12-31') if plot: pytplot.tplot(sites_loaded) # Return 1 as indication that the example finished without problems. return 1
def ex_spikes(plot=True): """Load GMAG data and show how to remove spikes.""" # Delete any existing pytplot variables. pytplot.del_data() # Define a time rage as a list trange = ['2007-03-23', '2007-03-23'] # Download gmag files and load data into pytplot variables. sites = ['ccnv'] var = 'thg_mag_ccnv' pyspedas.themis.gmag(sites=sites, trange=trange, varnames=[var]) pytplot.tplot_options('title', 'GMAG data, thg_mag_ccnv 2007-03-23') # Add spikes to data. data = pytplot.data_quants[var].values dlen = len(data) for i in range(1, 16): s = (1 if random.random() < 0.5 else -1) p1 = int(i * dlen / 16) data[p1, 0] = s * i * 40000 data[p1 + 2000, 1] = s * i * 30000 data[p1 + 4000, 2] = s * i * 20000 pytplot.data_quants[var].values = data # Clean spikes. clean_spikes(var, sub_avg=True) # Plot all variables. if plot: pytplot.tplot(pytplot.tplot_names()) # Return 1 as indication that the example finished without problems. return 1
def tnames(pattern=None): """ Find pytplot names. Parameters ---------- pattern : str, optional Patern to search for. The default is None, which returns all names. Returns ------- name_list : list of str List of pytplot variables. """ name_list = list() all_names = tplot_names(quiet=True) if pattern is None: name_list.extend(all_names) else: if isinstance(pattern, str): name_list.extend(fnmatch.filter(all_names, pattern)) else: for p in pattern: name_list.extend(fnmatch.filter(all_names, p)) return name_list
def mms_fgm_remove_flags(probe, data_rate, level, instrument, suffix=''): """ This function removes data flagged by the FGM 'flag' variable (flags > 0), in order to only show science quality data by default. Parameters: probe : str or list of str probe or list of probes, valid values for MMS probes are ['1','2','3','4']. data_rate : str or list of str instrument data rates for FGM include 'brst' 'fast' 'slow' 'srvy'. The default is 'srvy'. level : str indicates level of data processing. the default if no level is specified is 'l2' suffix: str The tplot variable names will be given this suffix. By default, no suffix is added. """ if not isinstance(probe, list): probe = [probe] if not isinstance(data_rate, list): data_rate = [data_rate] if not isinstance(level, list): level = [level] tplot_vars = set(tplot_names()) for this_probe in probe: for this_dr in data_rate: for this_lvl in level: flag_var = 'mms' + this_probe + '_' + instrument + '_flag_' + this_dr + '_' + this_lvl + suffix times, flags = get_data('mms' + this_probe + '_' + instrument + '_flag_' + this_dr + '_' + this_lvl + suffix) flagged_data = np.where(flags != 0.0)[0] for var_specifier in [ '_b_gse_', '_b_gsm_', '_b_dmpa_', '_b_bcs_' ]: var_name = 'mms' + this_probe + '_' + instrument + var_specifier + this_dr + '_' + this_lvl + suffix if var_name in tplot_vars: times, var_data = get_data(var_name) var_data[flagged_data] = np.nan store_data(var_name, data={'x': times, 'y': var_data})
no_download=False) # Load validation variables filename = calfile[0] pytplot.tplot_restore(filename) tha_fit_idl = pytplot.get_data('tha_fit') tha_fgs_idl = pytplot.get_data('tha_fgs') tha_fgs_sigma_idl = pytplot.get_data('tha_fgs_sigma') tha_fit_bfit_idl = pytplot.get_data('tha_fit_bfit') tha_fit_efit_idl = pytplot.get_data('tha_fit_efit') tha_efs_idl = pytplot.get_data('tha_efs') tha_efs_sigma_idl = pytplot.get_data('tha_efs_sigma') tha_efs_0_idl = pytplot.get_data('tha_efs_0') tha_efs_dot0_idl = pytplot.get_data('tha_efs_dot0') pytplot.tplot_names() pytplot.del_data('*') filename = nocalfile[0] pytplot.tplot_restore(filename) tha_efs_idl_no_cal = pytplot.get_data('tha_efs') pytplot.tplot_names() pytplot.del_data('*') t = ['2008-03-15', '2008-03-16'] pyspedas.themis.fit(trange=t, probe='a', level='l1', get_support_data=True, varnames=['tha_fit', 'tha_fit_code', 'tha_fit_npts'],
def dsl2gse(name_in, spinras, spindec, name_out, isgsetodsl=0): """Transform dsl to gse. Parameters ---------- name_in: str Name of input pytplot variable (eg. 'tha_fgl_dsl') spinras: str Name of pytplot variable for spin (eg.'tha_spinras'). spindec: str Name of pytplot variable for spin (eg.'tha_spinras'). name_out: str Name of output pytplot variable (eg. 'tha_fgl_gse') isgsetodsl: bool If 0 (default) then DSL to GSE. If 1, then GSE to DSL. Returns ------- 1 for sucessful completion. """ all_names = pytplot.tplot_names() needed_vars = [name_in, spinras, spindec] c = [value for value in needed_vars if value in all_names] if len(c) < 3: print("Variables needed: " + str(needed_vars)) m = [value for value in needed_vars if value not in c] print("Variables missing: " + str(m)) print("Please load missing variables.") return # Interpolate spinras and spindec spinnames_in = [spinras, spindec] hiras_name = spinras + '_hires' hidec_name = spindec + '_hires' hi_names = [hiras_name, hidec_name] # If new names exist, delete the variables if hiras_name in pytplot.tplot_names(): pytplot.del_data(hiras_name) if hidec_name in pytplot.tplot_names(): pytplot.del_data(hidec_name) pyspedas.tinterpol(spinnames_in, name_in, method="linear", newname=hi_names, suffix='') # Get data data_in = pytplot.get_data(name_in) data_ras = pytplot.get_data(hiras_name) data_dec = pytplot.get_data(hidec_name) # Make a unit vector that points along the spin axis spla = (90.0 - (data_dec[1])) * np.pi / 180.0 splo = data_ras[1] * np.pi / 180.0 # spherical to cartesian zscs0 = np.sin(spla) * np.cos(splo) zscs1 = np.sin(spla) * np.sin(splo) zscs2 = np.cos(spla) zscs = np.column_stack((zscs0, zscs1, zscs2)) # unit vector that points along the spin axis in GSE trgse = subgei2gse(data_in[0], zscs) zgse = [trgse[:, 0], trgse[:, 1], trgse[:, 2]] sun = [1.0, 0.0, 0.0] yscs = [ zgse[1] * sun[2] - zgse[2] * sun[1], zgse[2] * sun[0] - zgse[0] * sun[2], zgse[0] * sun[1] - zgse[1] * sun[0] ] yscsNorm = np.sqrt(yscs[0]**2.0 + yscs[1]**2.0 + yscs[2]**2.0) yscs = yscs / yscsNorm xscs = [ yscs[1] * zgse[2] - yscs[2] * zgse[1], yscs[2] * zgse[0] - yscs[0] * zgse[2], yscs[0] * zgse[1] - yscs[1] * zgse[0] ] if isgsetodsl == 0: # DSL -> GSE dd = data_in[1] d0 = dd[:, 0] * xscs[0] + dd[:, 1] * yscs[0] + dd[:, 2] * zgse[0] d1 = dd[:, 0] * xscs[1] + dd[:, 1] * yscs[1] + dd[:, 2] * zgse[1] d2 = dd[:, 0] * xscs[2] + dd[:, 1] * yscs[2] + dd[:, 2] * zgse[2] else: # GSE -> DSL dd = data_in[1] d0 = dd[:, 0] * xscs[0] + dd[:, 1] * xscs[1] + dd[:, 2] * xscs[2] d1 = dd[:, 0] * yscs[0] + dd[:, 1] * yscs[1] + dd[:, 2] * yscs[2] d2 = dd[:, 0] * zgse[0] + dd[:, 1] * zgse[1] + dd[:, 2] * zgse[2] dd_out = [d0, d1, d2] data_out = np.column_stack(dd_out) pytplot.store_data(name_out, data={'x': data_in[0], 'y': data_out}) return 1
def dsi2j2000(name_in=None, name_out=None, no_orb=False, J20002DSI=False, noload=False): """ This function transform a time series data between the DSI and J2000 coordinate systems Parameters: name_in : str input tplot variable to be transformed name_out : str Name of the tplot variable in which the transformed data is stored J20002DSI : bool Set to transform data from J2000 to DSI. If not set, it transforms data from DSI to J2000. Returns: None """ if (name_in is None) or (name_in not in tplot_names(quiet=True)): print('Input of Tplot name is undifiend') return if name_out is None: print('Tplot name for output is undifiend') name_out = 'result_of_dsi2j2000' # prepare for transformed Tplot Variable reload = not noload dl_in = get_data(name_in, metadata=True) get_data_array = get_data(name_in) time_array = get_data_array[0] time_length = time_array.shape[0] dat = get_data_array[1] # Get the SGI axis by interpolating the attitude data dsiz_j2000 = erg_interpolate_att(name_in, noload=noload)['sgiz_j2000'] # Sun direction in J2000 sundir = np.array([[1., 0., 0.]]*time_length) if no_orb: store_data('sundir_gse', data={'x': time_array, 'y': sundir}) else: # Calculate the sun directions from the instantaneous satellite locations if reload: tr = get_timespan(name_in) orb(trange=time_string([tr[0] - 60., tr[1] + 60.])) tinterpol('erg_orb_l2_pos_gse', time_array) scpos = get_data('erg_orb_l2_pos_gse-itrp')[1] sunpos = np.array([[1.496e+08, 0., 0.]]*time_length) sundir = sunpos - scpos store_data('sundir_gse', data={'x': time_array, 'y': sundir}) tnormalize('sundir_gse', newname='sundir_gse') # Derive DSI-X and DSI-Y axis vectors in J2000. # The elementary vectors below are the definition of DSI. The detailed relationship # between the spin phase, sun pulse timing, sun direction, and the actual subsolar point # on the spining s/c body should be incorporated into the calculation below. if reload: cotrans(name_in='sundir_gse', name_out='sundir_j2000', coord_in='gse', coord_out='j2000') sun_j2000 = get_data('sundir_j2000') dsiy = tcrossp(dsiz_j2000['y'], sun_j2000[1], return_data=True) dsix = tcrossp(dsiy, dsiz_j2000['y'], return_data=True) dsix_j2000 = {'x': time_array, 'y': dsix} dsiy_j2000 = {'x': time_array, 'y': dsiy} if not J20002DSI: print('DSI --> J2000') mat = cart_trans_matrix_make( dsix_j2000['y'], dsiy_j2000['y'], dsiz_j2000['y']) j2000x_in_dsi = np.dot(mat, np.array([1., 0., 0.])) j2000y_in_dsi = np.dot(mat, np.array([0., 1., 0.])) j2000z_in_dsi = np.dot(mat, np.array([0., 0., 1.])) mat = cart_trans_matrix_make( j2000x_in_dsi, j2000y_in_dsi, j2000z_in_dsi) dat_new = np.einsum("ijk,ik->ij", mat, dat) else: print('J2000 --> DSI') mat = cart_trans_matrix_make( dsix_j2000['y'], dsiy_j2000['y'], dsiz_j2000['y']) dat_new = np.einsum("ijk,ik->ij", mat, dat) store_data(name_out, data={'x': time_array, 'y': dat_new}, attr_dict=dl_in) options(name_out, 'ytitle', '\n'.join(name_out.split('_')))
""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """ BARREL 2016 mission """ """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" p4 = ['4A', '4D', '4G', '4B', '4E', '4H'] p4s = [] for count, i in enumerate(p4): p4s.append("$" + p4[count] + "$") fn = 'barrel_mission4_ephem_allpayloads.tplot' pytplot.tplot_restore(pathbarrel + fn) #Get the times for the first BARREL mission. All payloads have been interpolated to a common time base tn = pytplot.tplot_names() d = pytplot.get_data('L_Kp2_' + p4[0] + '_interp') bar4t = d[0] #Turn BARREL times into datetime list bar4tt = np.ndarray.tolist(bar4t) bar4t_dt = [] for i in bar4tt: bar4t_dt.append(datetime.datetime.fromtimestamp(i)) #Now load the data for each payload and append to array dat4L = [] for i in p4: d = pytplot.get_data('L_Kp2_' + i + '_interp') tmp = np.ndarray.tolist(d[1]) dat4L.append([tmp])
def sga2sgi(name_in=None, name_out=None, SGI2SGA=False, noload=False): """ This transform a time series data between the SGA and SGI coordinate systems. Parameters: name_in : str input tplot variable to be transformed name_out : str Name of the tplot variable in which the transformed data is stored SGI2SGA : bool Set to transform data from SGI to SGA. If not set, it transforms data from SGA to SGI. Returns: None """ if (name_in is None) or (name_in not in tplot_names(quiet=True)): print('Input of Tplot name is undifiend') return if name_out is None: print('Tplot name for output is undifiend') name_out = 'result_of_sga2sgi' get_data_vars = get_data(name_in) dl_in = get_data(name_in, metadata=True) time_array = get_data_vars[0] time_length = time_array.shape[0] dat = get_data_vars[1] # Get the SGA and SGI axes by interpolating the attitude data interpolated_values = erg_interpolate_att(name_in, noload=noload) sgix = interpolated_values['sgix_j2000']['y'] sgiy = interpolated_values['sgiy_j2000']['y'] sgiz = interpolated_values['sgiz_j2000']['y'] sgax = interpolated_values['sgax_j2000']['y'] sgay = interpolated_values['sgay_j2000']['y'] sgaz = interpolated_values['sgaz_j2000']['y'] if not SGI2SGA: print('SGA --> SGI') coord_out = 'sgi' # Transform SGI-X,Y,Z axis unit vectors in J2000 to those in SGA mat = cart_trans_matrix_make(sgax, sgay, sgaz) sgix_in_sga = np.einsum("ijk,ik->ij", mat, sgix) sgiy_in_sga = np.einsum("ijk,ik->ij", mat, sgiy) sgiz_in_sga = np.einsum("ijk,ik->ij", mat, sgiz) # Now transform the given vector in SGA to those in SGI mat = cart_trans_matrix_make(sgix_in_sga, sgiy_in_sga, sgiz_in_sga) dat_new = np.einsum("ijk,ik->ij", mat, dat) else: print('SGI --> SGA') coord_out = 'sga' # Transform SGA-X,Y,Z axis unit vectors in J2000 to those in SGI mat = cart_trans_matrix_make(sgix, sgiy, sgiz) sgax_in_sgi = np.einsum("ijk,ik->ij", mat, sgax) sgay_in_sgi = np.einsum("ijk,ik->ij", mat, sgay) sgaz_in_sgi = np.einsum("ijk,ik->ij", mat, sgaz) # Now transform the given vector in SGI to those in SGA mat = cart_trans_matrix_make(sgax_in_sgi, sgay_in_sgi, sgaz_in_sgi) dat_new = np.einsum("ijk,ik->ij", mat, dat) # Store the converted data in a tplot variable store_data(name_out, data={'x': time_array, 'y': dat_new}, attr_dict=dl_in) options(name_out, 'ytitle', '\n'.join(name_out.split('_')))
# and all GMAG stations, see: http://themis.ssl.berkeley.edu/gmag/gmag_list.php # # Get a list of the GMAG stations that belong to the EPO group. sites = gmag_list(group='epo') #################################################################################### # Download cdf files for all EPO GMAG stations and load data into pytplot variables. # # Some GMAG stations may not have any data files for the specified time interval. # In that case, we will get an error message that the remote file does not exist # for that GMAG station. load_data('gmag', time_range, sites, '', '') #################################################################################### # Print the names of the loaded GMAG sites. sites_loaded = tplot_names() #################################################################################### # Subtract the average values for these sites. subtract_average(sites_loaded, '') #################################################################################### # Download AE index data. load_data('gmag', time_range, ['idx'], '', '') #################################################################################### # Get a list of all the loaded GMAG sites plus the AE index data. sites_loaded = tplot_names() #################################################################################### # Plot GMAG and AE index data.
def cal_fit(probe='a', no_cal=False): """ Converts raw FIT parameter data into physical quantities. Warning: This function is in debug state Currently, it assumes that "th?_fit" variable is already loaded Parameters: probe: str Spacecraft probe letter ('a', 'b', 'c', 'd' and/or 'e') no_cal: bool If ture do not apply boom shortening factor or Ex offset defaults Returns: th?_fgs tplot variable """ import math import numpy as np import logging from pytplot import get_data, store_data, tplot_names, options from pyspedas.utilities.download import download from pyspedas.themis.config import CONFIG from pyspedas.utilities.time_double import time_float_one from copy import deepcopy from numpy.linalg import inv if probe == 'f': logging.warning( f"Probe f is not supported. Please use IDL version of 'thm_cal_fit' in SPEDAS." ) return # calibration parameters lv12 = 49.6 # m lv34 = 40.4 # m lv56 = 5.6 # m # This values provide better agreement with IDL lv12 = 49.599997 lv34 = 40.400003 lv56 = 5.59999981 # calibration table cpar = { "e12": { "cal_par_time": '2002-01-01/00:00:00', "Ascale": -15000.0 / (lv12 * 2.**15.), "Bscale": -15000.0 / (lv12 * 2.**15.), "Cscale": -15000.0 / (lv12 * 2.**15.), "theta": 0.0, "sigscale": 15000. / (lv12 * 2.**15.), "Zscale": -15000. / (lv56 * 2.**15.), "units": 'mV/m' }, "e34": { "cal_par_time": '2002-01-01/00:00:00', "Ascale": -15000.0 / (lv34 * 2.**15.), "Bscale": -15000.0 / (lv34 * 2.**15.), "Cscale": -15000.0 / (lv34 * 2.**15.), "theta": 0.0, "sigscale": 15000. / (lv34 * 2.**15.), "Zscale": -15000. / (lv56 * 2.**15.), "units": 'mV/m' }, "b": { "cal_par_time": '2002-01-01/00:00:00', "Ascale": 1., "Bscale": 1., "Cscale": 1., "theta": 0.0, "sigscale": 1., "Zscale": 1., "units": 'nT' } } # tplot options color_str = ['blue', 'green', 'red'] color_str2 = ['magenta', 'blue', 'cyan', 'green', 'orange'] b_str = ['Bx', 'By', 'Bz'] e_str = ['Ex', 'Ey', 'Ez'] b_units = cpar['b']['units'] e_units = cpar['e12']['units'] b_units_str = f'[{b_units}]' e_units_str = f'[{e_units}]' b_data_att = { 'units': b_units, 'cal_par_time': cpar['b']['cal_par_time'], 'data_type': 'calibrated', 'coord_sys': 'dsl' } b_data_att_sigma = {'units': b_units} e_data_att = { 'units': e_units, 'cal_par_time': cpar['e12']['cal_par_time'], 'data_type': 'calibrated', 'coord_sys': 'dsl' } e_data_att_sigma = {'units': e_units} b_opt_dict = { 'legend_names': b_str, 'ysubtitle': b_units_str, 'color': color_str, 'alpha': 1 } e_opt_dict = { 'legend_names': e_str, 'ysubtitle': e_units_str, 'color': color_str, 'alpha': 1 } # if tplot does not show 5th legend name, update tplot b_opt_dict2 = { 'legend_names': ['A', 'B', 'C', 'Sig', '<Bz>'], 'ysubtitle': b_units_str, 'color': color_str2, 'alpha': 1 } e_opt_dict2 = { 'legend_names': ['A', 'B', 'C', 'Sig', '<Ez>'], 'ysubtitle': e_units_str, 'color': color_str2, 'alpha': 1 } # Get list of tplot variables tnames = tplot_names(True) # True for quiet output # Get data from th?_fit variable tvar = 'th' + probe + '_fit' # B-field fit (FGM) processing if tvar not in tnames: logging.warning(f"Variable {tvar} is not found") return # Using deep copy to create an independent instance d = deepcopy(get_data( tvar)) # NOTE: Indexes are not the same as in SPEDAS, e.g. 27888x2x5 # establish probe number in cal tables sclist = { 'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': -1 } # for probe 'f' no flatsat FGM cal files scn = sclist[probe] # Rotation vectors rotBxy_angles = [ 29.95, 29.95, 29.95, 29.95, 29.95 ] # vassilis 6/2/2007: deg to rotate FIT on spin plane to match DSL on 5/4 rotBxy = rotBxy_angles[ scn] # vassilis 4/28: probably should be part of CAL table as well... cs = math.cos(rotBxy * math.pi / 180) # vassilis sn = math.sin(rotBxy * math.pi / 180) # vassilis adc2nT = 50000. / 2.**24 # vassilis 2007 - 04 - 03 # B - field fit(FGM) i = 1 d.y[:, i, 0] = cpar['b']['Ascale'] * d.y[:, i, 0] * adc2nT # vassilis d.y[:, i, 1] = cpar['b']['Bscale'] * d.y[:, i, 1] * adc2nT # vassilis d.y[:, i, 2] = cpar['b']['Cscale'] * d.y[:, i, 2] * adc2nT # vassilis d.y[:, i, 3] = cpar['b']['sigscale'] * d.y[:, i, 3] * adc2nT # vassilis d.y[:, i, 4] = cpar['b']['Zscale'] * d.y[:, i, 4] * adc2nT # vassilis # Calculating Bzoffset using thx+'/l1/fgm/0000/'+thx+'_fgmcal.txt' thx = 'th' + probe remote_name = thx + '/l1/fgm/0000/' + thx + '_fgmcal.txt' calfile = download(remote_file=remote_name, remote_path=CONFIG['remote_data_dir'], local_path=CONFIG['local_data_dir'], no_download=False) if not calfile: # This code should never be executed logging.warning(f"Calibration file {thx}_fgmcal.txt is not found") return caldata = np.loadtxt(calfile[0], converters={0: time_float_one}) # TODO: In SPEDAS we checks if data is already calibrated # Limit to the time of interest caltime = caldata[:, 0] t1 = np.nonzero(caltime < d.times.min())[0] # left time t2 = np.nonzero(caltime <= d.times.max())[0] # right time Bzoffset = np.zeros(d.times.shape) if t1.size + t2.size > 1: # Time range exist in the file tidx = np.arange(t1[-1], t2[-1] + 1) caltime = caltime[tidx] offi = caldata[tidx, 1:4] # col 1-3 cali = caldata[tidx, 4:13] # col 4-13 # spinperii = caldata[tidx, 13] # col 14 not in use flipxz = -1 * np.fliplr(np.identity(3)) # SPEDAS: offi2 = invert(transpose([cali[istart, 0:2], cali[istart, 3:5], cali[istart, 6:8]]) ## flipxz)##offi[istart, *] for t in range(0, caltime.size): offi2 = inv(np.c_[cali[t, 0:3], cali[t, 3:6], cali[t, 6:9]].T @ flipxz) @ offi[t, :] tidx = d.times >= caltime[t] Bzoffset[tidx] = offi2[2] # last element Bxprime = cs * d.y[:, i, 1] + sn * d.y[:, i, 2] Byprime = -sn * d.y[:, i, 1] + cs * d.y[:, i, 2] Bzprime = -d.y[:, i, 4] - Bzoffset # vassilis 4/28 (SUBTRACTING offset from spinaxis POSITIVE direction) # d is a namedtuple and does not support direct copy by value dprime = deepcopy(d) dprime.y[:, i, 1] = Bxprime # vassilis DSL dprime.y[:, i, 2] = Byprime # vassilis DSL dprime.y[:, i, 4] = Bzprime # vassilis DSL # Create fgs variable and remove nans fgs = dprime.y[:, i, [1, 2, 4]] idx = ~np.isnan(fgs[:, 0]) fgs_data = {'x': d.times[idx], 'y': fgs[idx, :]} # Save fgs tplot variable tvar = 'th' + probe + '_fgs' store_data(tvar, fgs_data, attr_dict=b_data_att) options(tvar, opt_dict=b_opt_dict) # Save fgs_sigma variable fit_sigma_data = {'x': d.times[idx], 'y': d.y[idx, i, 3]} tvar = 'th' + probe + '_fgs_sigma' store_data(tvar, fit_sigma_data, attr_dict=b_data_att_sigma) options(tvar, opt_dict=b_opt_dict) # Save bfit variable bfit_data = {'x': d.times[:], 'y': d.y[:, i, :].squeeze()} tvar = 'th' + probe + '_fit_bfit' store_data(tvar, bfit_data, attr_dict=b_data_att) options(tvar, opt_dict=b_opt_dict2) # E-field fit (EFI) processing # Get data from th?_fit_code variable tvar = 'th' + probe + '_fit_code' d_code = None # Blank variable, if d_code is not used if tvar in tnames: i = 0 d_code = get_data(tvar) e12_ss = (d_code.y[:, i] == int("e1", 16)) | (d_code.y[:, i] == int( "e5", 16)) e34_ss = (d_code.y[:, i] == int("e3", 16)) | (d_code.y[:, i] == int( "e7", 16)) else: # Default values (if no code) ne12 = d.times.size e12_ss = np.ones(ne12, dtype=bool) # create an index arrays e34_ss = np.zeros(ne12, dtype=bool) # Save 'efs' datatype before "hard wired" calibrations. # An EFI-style calibration is performed below. i = 0 efs = d.y[:, i, [1, 2, 4]] # Locate samples with non-NaN data values. Save the indices in # efsx_good, then at the end of calibration, pull the "good" # indices out of the calibrated efs[] array to make the thx_efs # tplot variable. efsx_good = ~np.isnan(efs[:, 0]) if np.any(efsx_good): if np.any( e34_ss ): # rotate efs 90 degrees if necessary, if e34 was used in spinfit tmp = d.y[e34_ss, i, :] # Apply logical arrays # TODO: there should be a better way to combine indexes efs[e34_ss, :] = tmp[:, [2, 1, 4]] # Apply dimension selection efs[e34_ss, 0] = -efs[e34_ss, 0] efsz = d.y[:, i, 4] # save Ez separately, for possibility that it's the SC potential # Use cpar to calibrate if np.any(e12_ss): d.y[e12_ss, i, 0] = cpar["e12"]["Ascale"] * d.y[e12_ss, i, 0] d.y[e12_ss, i, 1] = cpar["e12"]["Bscale"] * d.y[e12_ss, i, 1] d.y[e12_ss, i, 2] = cpar["e12"]["Cscale"] * d.y[e12_ss, i, 2] d.y[e12_ss, i, 3] = cpar["e12"]["sigscale"] * d.y[e12_ss, i, 3] d.y[e12_ss, i, 4] = cpar["e12"]["Zscale"] * d.y[e12_ss, i, 4] if np.any(e34_ss): d.y[e34_ss, i, 0] = cpar["e34"]["Ascale"] * d.y[e34_ss, i, 0] d.y[e34_ss, i, 1] = cpar["e34"]["Bscale"] * d.y[e34_ss, i, 1] d.y[e34_ss, i, 2] = cpar["e34"]["Cscale"] * d.y[e34_ss, i, 2] d.y[e34_ss, i, 3] = cpar["e34"]["sigscale"] * d.y[e34_ss, i, 3] d.y[e34_ss, i, 4] = cpar["e34"]["Zscale"] * d.y[e34_ss, i, 4] # save fit_efit variable fit_efit_data = {'x': d.times, 'y': d.y[:, i, :]} tvar = 'th' + probe + '_fit_efit' store_data(tvar, fit_efit_data, attr_dict=e_data_att) options(tvar, opt_dict=e_opt_dict2) # thx_efs and thx_efs_sigma, # Calibrate efs data by applying E12 calibration factors, not despinning, then applying despun (spin-dependent) # calibration factors from E12 (the spin-independent offset is subtracted on-board): # Load calibration file, e.g. tha/l1/eff/0000/tha_efi_calib_params.txt remote_name = thx + '/l1/eff/0000/' + thx + '_efi_calib_params.txt' eficalfile = download(remote_file=remote_name, remote_path=CONFIG['remote_data_dir'], local_path=CONFIG['local_data_dir'], no_download=False) if not eficalfile: # This code should never be executed logging.warning( f"Calibration file {thx}_efi_calib_params.txt is not found") return colnums = { "time": [0], "edc_offset": [14, 15, 16], "edc_gain": [17, 18, 19], "BOOM_LENGTH": [26, 27, 28], "BOOM_SHORTING_FACTOR": [29, 30, 31], "DSC_OFFSET": [32, 33, 34] } # List of columns to be loaded collist = list() [collist.extend(cnum) for cnum in colnums.values()] collist.sort() # ensurer that the list of columns is sorted eficaltxt = np.loadtxt(eficalfile[0], skiprows=1, max_rows=1, converters={0: time_float_one}, usecols=collist) eficaldata = { "time": eficaltxt[0], "gain": eficaltxt[4:7], "offset": eficaltxt[1:4], "boom_length": eficaltxt[7:10], "boom_shorting_factor": eficaltxt[10:13], "dsc_offset": eficaltxt[13:16] } # Boom exx = eficaldata["boom_length"] if not no_cal: exx *= eficaldata["boom_shorting_factor"] # Calibrate E field # Calibrate Ex and Ey spinfits that are derived from E12 only! if np.any(e12_ss): efs[e12_ss, 0:2] = -1000. * eficaldata["gain"][0] * efs[e12_ss, 0:2] / exx[0] if np.any(e34_ss): efs[e34_ss, 0:2] = -1000. * eficaldata["gain"][1] * efs[e34_ss, 0:2] / exx[1] # Calibrate Ez spinfit by itself: efs[:, 2] = -1000. * eficaldata["gain"][2] * efs[:, 2] / exx[2] # DC Offset if not no_cal: efs -= eficaldata["dsc_offset"] # Here, if the fit_code is 'e5'x (229) then efs[*,2] contains the spacecraft potential, so set all of those values # to Nan, jmm, 19-Apr-2010 # Or if the fit_code is 'e7'x (231), this will also be including the SC potential, jmm,22-oct-2010 if d_code is not None: sc_port = (d_code.y[:, i] == int("e5", 16)) | (d_code.y[:, i] == int( "e7", 16)) if np.any(sc_port): efs[sc_port, 2] = np.nan # save efs variable efs_data = { 'x': d.times[efsx_good], 'y': efs[efsx_good, :] } # efs[efsx_good,*] tvar = 'th' + probe + '_efs' store_data(tvar, efs_data, attr_dict=e_data_att) options(tvar, opt_dict=e_opt_dict) # save efs_sigma variable efs_sigma_data = { 'x': d.times[efsx_good], 'y': d.y[efsx_good, i, 3] } # d.y[efsx_good, 3, idx] tvar = 'th' + probe + '_efs_sigma' store_data(tvar, efs_sigma_data, attr_dict=e_data_att_sigma) options(tvar, opt_dict=e_opt_dict) # save efs_0 efs_0_data = deepcopy(efs) efs_0_data[:, 2] = 0 efs_0 = {'x': d.times[efsx_good], 'y': efs_0_data[efsx_good, :]} tvar = 'th' + probe + '_efs_0' store_data(tvar, efs_0, attr_dict=e_data_att_sigma) options(tvar, opt_dict=e_opt_dict) # calculate efs_dot0 Ez = (efs[:, 0] * fgs[:, 0] + efs[:, 1] * fgs[:, 1]) / (-1 * fgs[:, 2]) angle = np.arccos( fgs[:, 2] / np.sqrt(np.sum(fgs**2, axis=1))) * 180 / np.pi angle80 = angle > 80 if np.any(angle80): Ez[angle80] = np.NaN efx_dot0_data = deepcopy(efs) efx_dot0_data[:, 2] = Ez # save efs_dot0 efs_dot0 = {'x': d.times[efsx_good], 'y': efx_dot0_data[efsx_good, :]} tvar = 'th' + probe + '_efs_dot0' store_data(tvar, efs_dot0, attr_dict=e_data_att_sigma) options(tvar, opt_dict=e_opt_dict)
def test_math(): pytplot.cdf_to_tplot(os.path.dirname(os.path.realpath(__file__)) + "/testfiles/mvn_euv_l2_bands_20170619_v09_r03.cdf") pytplot.tplot_names() pytplot.tplot_math.split_vec('mvn_euv_calib_bands') pytplot.tplot('mvn_euv_calib_bands_x', testing=True) pytplot.tplot_math.subtract('mvn_euv_calib_bands_x', 'mvn_euv_calib_bands_y', new_tvar='s') pytplot.tplot('s', testing=True) pytplot.tplot_math.add('s', 'mvn_euv_calib_bands_x', new_tvar='a') pytplot.tplot(['mvn_euv_calib_bands_x', 'a'], testing=True) pytplot.tplot_math.subtract('mvn_euv_calib_bands_x', 'mvn_euv_calib_bands_z', new_tvar='m') pytplot.tplot('m', testing=True) pytplot.tplot_math.divide('m', 'mvn_euv_calib_bands_z', new_tvar='d') pytplot.tplot('d', testing=True) pytplot.add_across('mvn_euv_calib_bands', new_tvar='data_summed') pytplot.tplot('mvn_euv_calib_bands', testing=True) pytplot.avg_res_data('data_summed', res=120) pytplot.tplot('data_summed', testing=True) pytplot.deflag('mvn_euv_calib_bands', 0, new_tvar='deflagged') pytplot.tplot('deflagged', testing=True) pytplot.flatten('mvn_euv_calib_bands') pytplot.tplot('data_flattened', testing=True) pytplot.join_vec(['mvn_euv_calib_bands_x', 'mvn_euv_calib_bands_y', 'mvn_euv_calib_bands_z'], new_tvar='data2') pytplot.tplot('data2', testing=True) pytplot.pwr_spec('mvn_euv_calib_bands_x') pytplot.tplot('mvn_euv_calib_bands_x_pwrspec', testing=True) pytplot.derive('mvn_euv_calib_bands_x') pytplot.store_data("data3", data=['mvn_euv_calib_bands_x', 'mvn_euv_calib_bands_y', 'mvn_euv_calib_bands_z']) pytplot.tplot('data3', testing=True) pytplot.cdf_to_tplot(os.path.dirname(os.path.realpath(__file__))+ "/testfiles/mvn_swe_l2_svyspec_20170619_v04_r04.cdf") pytplot.resample('mvn_euv_calib_bands_y', pytplot.data_quants['diff_en_fluxes'].coords['time'].values, new_tvar='data_3_resampled') pytplot.tplot('data_3_resampled', testing=True) pytplot.options('diff_en_fluxes', 'spec', 1) pytplot.spec_mult('diff_en_fluxes') pytplot.add_across('diff_en_fluxes_specmult', new_tvar='tot_en_flux', column_range=[[0, 10], [10, 20], [20, 30]]) pytplot.options('diff_en_fluxes', 'ylog', 1) pytplot.options('diff_en_fluxes', 'zlog', 1) pytplot.options('tot_en_flux', 'ylog', 1) pytplot.ylim('tot_en_flux', 1, 100) pytplot.tplot(['diff_en_fluxes', 'tot_en_flux'], testing=True) pytplot.split_vec('tot_en_flux') pytplot.add('tot_en_flux_x', 'mvn_euv_calib_bands_y', new_tvar='weird_data') pytplot.tplot('weird_data', testing=True)
def mms_fpi_set_metadata(probe, data_rate, datatype, level, suffix=''): """ This function updates the metadata for FPI data products Parameters: probe : str or list of str probe or list of probes, valid values for MMS probes are ['1','2','3','4']. data_rate : str or list of str instrument data rates for FPI include 'brst' and 'fast'. The default is 'fast'. level : str indicates level of data processing. the default if no level is specified is 'l2' suffix: str The tplot variable names will be given this suffix. By default, no suffix is added. """ if not isinstance(probe, list): probe = [probe] if not isinstance(data_rate, list): data_rate = [data_rate] if not isinstance(datatype, list): datatype = [datatype] if not isinstance(level, list): level = [level] probe = [str(p) for p in probe] tvars = set(tplot_names()) for this_probe in probe: for this_dr in data_rate: for this_lvl in level: for this_dtype in datatype: if this_dtype == 'des-moms': if 'mms' + this_probe + '_des_energyspectr_par_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_energyspectr_par_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES (eV)') options( 'mms' + this_probe + '_des_energyspectr_par_' + this_dr + suffix, 'ylog', True) options( 'mms' + this_probe + '_des_energyspectr_par_' + this_dr + suffix, 'zlog', True) options( 'mms' + this_probe + '_des_energyspectr_par_' + this_dr + suffix, 'Colormap', 'jet') options( 'mms' + this_probe + '_des_energyspectr_par_' + this_dr + suffix, 'ztitle', '[keV/(cm^2 s sr keV)]') options( 'mms' + this_probe + '_des_energyspectr_par_' + this_dr + suffix, 'spec', True) if 'mms' + this_probe + '_des_energyspectr_anti_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_energyspectr_anti_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES (eV)') options( 'mms' + this_probe + '_des_energyspectr_anti_' + this_dr + suffix, 'ylog', True) options( 'mms' + this_probe + '_des_energyspectr_anti_' + this_dr + suffix, 'zlog', True) options( 'mms' + this_probe + '_des_energyspectr_anti_' + this_dr + suffix, 'Colormap', 'jet') options( 'mms' + this_probe + '_des_energyspectr_anti_' + this_dr + suffix, 'ztitle', '[keV/(cm^2 s sr keV)]') if 'mms' + this_probe + '_des_energyspectr_perp_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_energyspectr_perp_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES (eV)') options( 'mms' + this_probe + '_des_energyspectr_perp_' + this_dr + suffix, 'ylog', True) options( 'mms' + this_probe + '_des_energyspectr_perp_' + this_dr + suffix, 'zlog', True) options( 'mms' + this_probe + '_des_energyspectr_perp_' + this_dr + suffix, 'Colormap', 'jet') options( 'mms' + this_probe + '_des_energyspectr_perp_' + this_dr + suffix, 'ztitle', '[keV/(cm^2 s sr keV)]') options( 'mms' + this_probe + '_des_energyspectr_anti_' + this_dr + suffix, 'spec', True) if 'mms' + this_probe + '_des_energyspectr_omni_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_energyspectr_omni_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES (eV)') options( 'mms' + this_probe + '_des_energyspectr_omni_' + this_dr + suffix, 'ylog', True) options( 'mms' + this_probe + '_des_energyspectr_omni_' + this_dr + suffix, 'zlog', True) options( 'mms' + this_probe + '_des_energyspectr_omni_' + this_dr + suffix, 'Colormap', 'jet') options( 'mms' + this_probe + '_des_energyspectr_omni_' + this_dr + suffix, 'ztitle', '[keV/(cm^2 s sr keV)]') options( 'mms' + this_probe + '_des_energyspectr_omni_' + this_dr + suffix, 'spec', True) if 'mms' + this_probe + '_des_pitchangdist_lowen_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_pitchangdist_lowen_' + this_dr + suffix, 'zlog', True) options( 'mms' + this_probe + '_des_pitchangdist_lowen_' + this_dr + suffix, 'Colormap', 'jet') options( 'mms' + this_probe + '_des_pitchangdist_lowen_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES (deg)') options( 'mms' + this_probe + '_des_pitchangdist_lowen_' + this_dr + suffix, 'ztitle', '[keV/(cm^2 s sr keV)]') options( 'mms' + this_probe + '_des_pitchangdist_lowen_' + this_dr + suffix, 'spec', True) if 'mms' + this_probe + '_des_pitchangdist_miden_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_pitchangdist_miden_' + this_dr + suffix, 'zlog', True) options( 'mms' + this_probe + '_des_pitchangdist_miden_' + this_dr + suffix, 'Colormap', 'jet') options( 'mms' + this_probe + '_des_pitchangdist_miden_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES (deg)') options( 'mms' + this_probe + '_des_pitchangdist_miden_' + this_dr + suffix, 'ztitle', '[keV/(cm^2 s sr keV)]') options( 'mms' + this_probe + '_des_pitchangdist_miden_' + this_dr + suffix, 'spec', True) if 'mms' + this_probe + '_des_pitchangdist_highen_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_pitchangdist_highen_' + this_dr + suffix, 'zlog', True) options( 'mms' + this_probe + '_des_pitchangdist_highen_' + this_dr + suffix, 'Colormap', 'jet') options( 'mms' + this_probe + '_des_pitchangdist_highen_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES (deg)') options( 'mms' + this_probe + '_des_pitchangdist_highen_' + this_dr + suffix, 'ztitle', '[keV/(cm^2 s sr keV)]') options( 'mms' + this_probe + '_des_pitchangdist_highen_' + this_dr + suffix, 'spec', True) if 'mms' + this_probe + '_des_bulkv_dbcs_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_bulkv_dbcs_' + this_dr + suffix, 'color', ['b', 'g', 'r']) options( 'mms' + this_probe + '_des_bulkv_dbcs_' + this_dr + suffix, 'legend_names', ['Vx DBCS', 'Vy DBCS', 'Vz DBCS']) options( 'mms' + this_probe + '_des_bulkv_dbcs_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES velocity (km/s)') if 'mms' + this_probe + '_des_bulkv_gse_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_bulkv_gse_' + this_dr + suffix, 'color', ['b', 'g', 'r']) options( 'mms' + this_probe + '_des_bulkv_gse_' + this_dr + suffix, 'legend_names', ['Vx GSE', 'Vy GSE', 'Vz GSE']) options( 'mms' + this_probe + '_des_bulkv_gse_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES velocity (km/s)') if 'mms' + this_probe + '_des_numberdensity_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_des_numberdensity_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DES density (cm^-3)') elif this_dtype == 'dis-moms': if 'mms' + this_probe + '_dis_energyspectr_omni_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_dis_energyspectr_omni_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DIS (eV)') options( 'mms' + this_probe + '_dis_energyspectr_omni_' + this_dr + suffix, 'ylog', True) options( 'mms' + this_probe + '_dis_energyspectr_omni_' + this_dr + suffix, 'zlog', True) options( 'mms' + this_probe + '_dis_energyspectr_omni_' + this_dr + suffix, 'Colormap', 'jet') options( 'mms' + this_probe + '_dis_energyspectr_omni_' + this_dr + suffix, 'ztitle', '[keV/(cm^2 s sr keV)]') options( 'mms' + this_probe + '_dis_energyspectr_omni_' + this_dr + suffix, 'spec', True) if 'mms' + this_probe + '_dis_bulkv_dbcs_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_dis_bulkv_dbcs_' + this_dr + suffix, 'color', ['b', 'g', 'r']) options( 'mms' + this_probe + '_dis_bulkv_dbcs_' + this_dr + suffix, 'legend_names', ['Vx DBCS', 'Vy DBCS', 'Vz DBCS']) options( 'mms' + this_probe + '_dis_bulkv_dbcs_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DIS velocity (km/s)') if 'mms' + this_probe + '_dis_bulkv_gse_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_dis_bulkv_gse_' + this_dr + suffix, 'color', ['b', 'g', 'r']) options( 'mms' + this_probe + '_dis_bulkv_gse_' + this_dr + suffix, 'legend_names', ['Vx GSE', 'Vy GSE', 'Vz GSE']) options( 'mms' + this_probe + '_dis_bulkv_gse_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DIS velocity (km/s)') if 'mms' + this_probe + '_dis_numberdensity_' + this_dr + suffix in tvars: options( 'mms' + this_probe + '_dis_numberdensity_' + this_dr + suffix, 'ytitle', 'MMS' + this_probe + ' DIS density (cm^-3)')
mms_load_mec(probe=4) # find info on a load routine help(mms_load_mec) from pyspedas.mms import mms_load_fgm # note that the keywords are the same as in IDL mms_load_fgm(probe='4', data_rate='brst', trange=['2015-10-16/13:06', '2015-10-16/13:07'], time_clip=True) # find which variables were loaded from pytplot import tplot_names tplot_names() from pyspedas.mms import mms_load_edp # load some burst mode electric field data mms_load_edp(probe='4', data_rate='brst', trange=['2015-10-16/13:06', '2015-10-16/13:07'], time_clip=True) from pyspedas import tnames # the tnames function supports filtering with wild cards, e.g., # to find the E-field variables: dce_vars = tnames('*_edp_dce_*')
############################################################################## # Loading data into memory # ------------------------ # The pytplot package comes with a sample IDL tplot save file which will be used for the following tutorial, # located in PyTplot Github (https://github.com/MAVENSDC/PyTplot) under pytplot/pytplot/sampledata. # This file was generated in IDL, and therefore can be loaded into tplot if you wish to compare the # IDL and python versions. # Download the test file from the PyTplot Github acct url = 'https://github.com/MAVENSDC/PyTplot/raw/master/docs/test_data.tplot' urllib.request.urlretrieve(url, "./test_data.tplot") ############################################################################## # To load this data into pytplot, type in the following command: pytplot.tplot_restore(r'test_data.tplot') print(pytplot.tplot_names()) ############################################################################## # Storing data # ------------ # pytplot works by interacting with global variables (called tplot variables) that contain information necessary for # creating one panel (or even one portion of a panel) of a plot, that can be accessed from the main level or # within any Python routine. Before anything can be plotted, tplot variables must be loaded into memory. # Single line Plot: to store data to plot a single line, the 'y' data will be a single list of data # that will correspond to the points that will make up the line. # Multi-line Plot: to store data to plot a multi-line plot, the 'y' data will be a list of lists. # Each column of the "matrix" created is the data for one line. So if you had a list with four lists in it # and three elements in each list [[1,2,3],[4,5,6],[7,8,9],[10,11,12]] three lines with four data points each # will be plotted. # Spectrogram Plot: to store data to plot for a spectrogram, 'v' data will be a list of bins for the data, # and the 'y' data will be a matrix of values with dimensions of the length of "x" time the length of "v"
def sgi2dsi(name_in=None, name_out=None, DSI2SGI=False, noload=False): """ This transform a time series data between the SGI and DSI coordinate systems. Parameters: name_in : str input tplot variable to be transformed name_out : str Name of the tplot variable in which the transformed data is stored DSI2SGI : bool Set to transform data from DSI to SGI (despun coord --> spinning coord). If not set, it transforms data from SGI to DSI (spinning coord --> despun coord). Returns: None """ if (name_in is None) or (name_in not in tplot_names(quiet=True)): print('Input of Tplot name is undifiend') return if name_out is None: print('Tplot name for output is undifiend') name_out = 'result_of_sgi2dsi' # prepare for transformed Tplot Variable reload = not noload dl_in = get_data(name_in, metadata=True) get_data_array = get_data(name_in) time_array = get_data_array[0] time_length = time_array.shape[0] dat = get_data_array[1] # Get the SGA and SGI axes by interpolating the attitude data interpolated_values = erg_interpolate_att(name_in, noload=noload) sgix2ssix_angle = interpolated_values['sgiz_j2000']['y'][:, 0] # [deg] Now the constant angle is used, which is not correct, though sgix2ssix_angle[:] = 90. + 21.6 spperiod = interpolated_values['spinperiod']['y'] spphase = interpolated_values['spinphase']['y'] rot_axis = np.array([[0., 0., 1.]]*time_length) # SGI --> DSI (despin) if not DSI2SGI: print('SGI --> DSI') coor_out = 'dsi' rotated_vector = vector_rotate(x0=dat[:, 0], y0=dat[:, 1], z0=dat[:, 2], nx=rot_axis[:, 0], ny=rot_axis[:, 1], nz=rot_axis[:, 2], theta=-sgix2ssix_angle + spphase) else: # DSI --> SGI (spin) print('DSI --> SGI') coord_out = 'sgi' rotated_vector = vector_rotate(x0=dat[:, 0], y0=dat[:, 1], z0=dat[:, 2], nx=rot_axis[:, 0], ny=rot_axis[:,1], nz=rot_axis[:, 2], theta=-1.*(-sgix2ssix_angle + spphase)) store_data(name_out, data={'x': time_array, 'y': rotated_vector}, attr_dict=dl_in) options(name_out, 'ytitle', '\n'.join(name_out.split('_')))
def mms_fgm_set_metadata(probe, data_rate, level, instrument, suffix=''): """ This function updates the metadata for FGM data products Parameters: probe : str or list of str probe or list of probes, valid values for MMS probes are ['1','2','3','4']. data_rate : str or list of str instrument data rates for FGM include 'brst' 'fast' 'slow' 'srvy'. The default is 'srvy'. level : str indicates level of data processing. the default if no level is specified is 'l2' suffix: str The tplot variable names will be given this suffix. By default, no suffix is added. """ if not isinstance(probe, list): probe = [probe] if not isinstance(data_rate, list): data_rate = [data_rate] if not isinstance(level, list): level = [level] tvars = set(tplot_names()) for this_probe in probe: for this_dr in data_rate: for this_lvl in level: if 'mms' + this_probe + '_' + instrument + '_b_gse_' + this_dr + '_' + this_lvl + suffix in tvars: options( 'mms' + this_probe + '_' + instrument + '_b_gse_' + this_dr + '_' + this_lvl + suffix, 'ytitle', 'MMS' + this_probe + ' FGM') options( 'mms' + this_probe + '_' + instrument + '_b_gse_' + this_dr + '_' + this_lvl + suffix, 'color', ['b', 'g', 'r', '#000000']) options( 'mms' + this_probe + '_' + instrument + '_b_gse_' + this_dr + '_' + this_lvl + suffix, 'legend_names', ['Bx GSE', 'By GSE', 'Bz GSE', 'B total']) if 'mms' + this_probe + '_' + instrument + '_b_gsm_' + this_dr + '_' + this_lvl + suffix in tvars: options( 'mms' + this_probe + '_' + instrument + '_b_gsm_' + this_dr + '_' + this_lvl + suffix, 'ytitle', 'MMS' + this_probe + ' FGM') options( 'mms' + this_probe + '_' + instrument + '_b_gsm_' + this_dr + '_' + this_lvl + suffix, 'color', ['b', 'g', 'r', '#000000']) options( 'mms' + this_probe + '_' + instrument + '_b_gsm_' + this_dr + '_' + this_lvl + suffix, 'legend_names', ['Bx GSM', 'By GSM', 'Bz GSM', 'B total']) if 'mms' + this_probe + '_' + instrument + '_b_dmpa_' + this_dr + '_' + this_lvl + suffix in tvars: options( 'mms' + this_probe + '_' + instrument + '_b_dmpa_' + this_dr + '_' + this_lvl + suffix, 'ytitle', 'MMS' + this_probe + ' FGM') options( 'mms' + this_probe + '_' + instrument + '_b_dmpa_' + this_dr + '_' + this_lvl + suffix, 'color', ['b', 'g', 'r', '#000000']) options( 'mms' + this_probe + '_' + instrument + '_b_dmpa_' + this_dr + '_' + this_lvl + suffix, 'legend_names', ['Bx DMPA', 'By DMPA', 'Bz DMPA', 'B total']) if 'mms' + this_probe + '_' + instrument + '_b_bcs_' + this_dr + '_' + this_lvl + suffix in tvars: options( 'mms' + this_probe + '_' + instrument + '_b_bcs_' + this_dr + '_' + this_lvl + suffix, 'ytitle', 'MMS' + this_probe + ' FGM') options( 'mms' + this_probe + '_' + instrument + '_b_bcs_' + this_dr + '_' + this_lvl + suffix, 'color', ['b', 'g', 'r', '#000000']) options( 'mms' + this_probe + '_' + instrument + '_b_bcs_' + this_dr + '_' + this_lvl + suffix, 'legend_names', ['Bx BCS', 'By BCS', 'Bz BCS', 'B total'])