def pair_GPSGRACE(GPS_TS, GRACE_TS): # This resamples the GRACE data to match GPS that is within the range of GRACE, and forms a common time axis. gps_decyear = gps_ts_functions.get_float_times(GPS_TS.dtarray) grace_decyear = gps_ts_functions.get_float_times(GRACE_TS.dtarray) # the decimal years of all the grace obs points decyear = [] dtarray = [] north_gps, east_gps, vert_gps = [], [], [] N_err, E_err, V_err = [], [], [] for i in range( len(GPS_TS.dtarray) ): # this if-statement is happening because GPS is more current than GRACE if min(GRACE_TS.dtarray) < GPS_TS.dtarray[i] < max(GRACE_TS.dtarray): decyear.append(gps_decyear[i]) dtarray.append(GPS_TS.dtarray[i]) north_gps.append(GPS_TS.dN[i]) east_gps.append(GPS_TS.dE[i]) vert_gps.append(GPS_TS.dU[i]) N_err.append(GPS_TS.Sn[i]) E_err.append(GPS_TS.Se[i]) V_err.append(GPS_TS.Su[i]) grace_u = np.interp(decyear, grace_decyear, GRACE_TS.dE) grace_v = np.interp(decyear, grace_decyear, GRACE_TS.dN) grace_w = np.interp(decyear, grace_decyear, GRACE_TS.dU) my_paired_ts = Paired_TS(dtarray=dtarray, north=north_gps, east=east_gps, vert=vert_gps, N_err=N_err, E_err=E_err, V_err=V_err, u=grace_u, v=grace_v, w=grace_w) return my_paired_ts
def compute(dataobj_list, offsetobj_list, eqobj_list, fit_table, grace_dir,start_time_infl, end_time_infl,start_time_velo, end_time_velo, seasonal_type, N, Wn): # Initialize output objects noeq_objects = []; east_filt=[]; north_filt=[]; vert_filt=[]; east_inf_time=[]; north_inf_time=[]; vert_inf_time=[]; east_change=[]; north_change=[]; vert_change=[]; for i in range(len(dataobj_list)): # Remove the earthquakes and offsets newobj=offsets.remove_antenna_offsets(dataobj_list[i], offsetobj_list[i]); newobj=offsets.remove_earthquakes(newobj,eqobj_list[i]); newobj=gps_ts_functions.remove_outliers(newobj,15); # 15mm horizontal outliers newobj=gps_seasonal_removals.make_detrended_ts(newobj, 1, seasonal_type, fit_table, grace_dir); # can remove seasonals a few ways noeq_objects.append(newobj); print(dataobj_list[i].name); # Get the inflection points in the timeseries float_dtarray = gps_ts_functions.get_float_times(newobj.dtarray); [east_filtered, e_inflection_time, echange]=inflection_with_butterworth(newobj.dtarray, float_dtarray, newobj.dE, N, Wn, start_time_infl, end_time_infl,start_time_velo, end_time_velo); [north_filtered, n_inflection_time, nchange]=inflection_with_butterworth(newobj.dtarray, float_dtarray, newobj.dN, N, Wn, start_time_infl, end_time_infl,start_time_velo, end_time_velo); [vert_filtered, v_inflection_time, vchange]=inflection_with_butterworth(newobj.dtarray, float_dtarray, newobj.dU, N, Wn, start_time_infl, end_time_infl,start_time_velo, end_time_velo); east_filt.append(east_filtered); north_filt.append(north_filtered); vert_filt.append(vert_filtered); east_inf_time.append(e_inflection_time); north_inf_time.append(n_inflection_time); vert_inf_time.append(v_inflection_time); east_change.append(echange); north_change.append(nchange); vert_change.append(vchange); return [noeq_objects, east_filt, north_filt, vert_filt, east_inf_time, north_inf_time, vert_inf_time, east_change, north_change, vert_change];
def remove_seasonals_by_notch(Data): # Using Sang-Ho's notch filter script to remove power at frequencies corresponding to 1 year and 6 months. # We are also removing a linear trend in this step. Data = gps_ts_functions.remove_nans(Data); # Parameters # % x 1-D signal array # % fs sampling frequency, Hz # % fn notch frequency, Hz # % Bn notch bandwidth, Hz dt_interval = 1.0; # one day fs = 1 / dt_interval; fn1 = 1.0 / 365.24; # fn = notch frequency, annual Bn1 = 0.1 * fn1; fn2 = 2.0 / 365.24; # fn = notch frequency, semiannual Bn2 = 0.1 * fn2; # a choice: 10% seems to work well. decyear = gps_ts_functions.get_float_times(Data.dtarray); dE_detrended = np.zeros(np.shape(Data.dE)); dN_detrended = np.zeros(np.shape(Data.dN)); dU_detrended = np.zeros(np.shape(Data.dU)); dE_trended = np.zeros(np.shape(Data.dE)); dN_trended = np.zeros(np.shape(Data.dN)); dU_trended = np.zeros(np.shape(Data.dU)); # East x = Data.dE; dE_filt = notch_filter.notchfilt(x, fs, fn1, Bn1, filtfiltopt=True); dE_filt = notch_filter.notchfilt(dE_filt, fs, fn2, Bn2, filtfiltopt=True); east_coef = np.polyfit(decyear, dE_filt, 1)[0]; for i in range(len(dE_filt)): dE_detrended[i] = dE_filt[i] - east_coef * decyear[i] - (dE_filt[0] - east_coef * decyear[0]); dE_trended[i] = dE_filt[i]; # North x = Data.dN; dN_filt = notch_filter.notchfilt(x, fs, fn1, Bn1, filtfiltopt=True); dN_filt = notch_filter.notchfilt(dN_filt, fs, fn2, Bn2, filtfiltopt=True); north_coef = np.polyfit(decyear, dN_filt, 1)[0]; for i in range(len(dN_filt)): dN_detrended[i] = dN_filt[i] - north_coef * decyear[i] - (dN_filt[0] - north_coef * decyear[0]); dN_trended[i] = dN_filt[i]; # Up x = Data.dU; dU_filt = notch_filter.notchfilt(x, fs, fn1, Bn1, filtfiltopt=True); dU_filt = notch_filter.notchfilt(dU_filt, fs, fn2, Bn2, filtfiltopt=True); vert_coef = np.polyfit(decyear, dU_filt, 1)[0]; for i in range(len(dU_filt)): dU_detrended[i] = dU_filt[i] - vert_coef * decyear[i] - (dU_filt[0] - vert_coef * decyear[0]); dU_trended[i] = dU_filt[i]; detrended = gps_io_functions.Timeseries(name=Data.name, coords=Data.coords, dtarray=Data.dtarray, dN=dN_detrended, dE=dE_detrended, dU=dU_detrended, Sn=Data.Sn, Se=Data.Se, Su=Data.Su, EQtimes=Data.EQtimes); trended = gps_io_functions.Timeseries(name=Data.name, coords=Data.coords, dtarray=Data.dtarray, dN=dN_trended, dE=dE_trended, dU=dU_trended, Sn=Data.Sn, Se=Data.Se, Su=Data.Su, EQtimes=Data.EQtimes); return detrended, trended;
def remove_seasonals_by_GRACE(Data, grace_dir): # Here we use pre-computed GRACE load model time series to correct the GPS time series. # We recognize that the horizontals will be bad, and that the resolution of GRACE is coarse. # For these reasons, this is not an important part of the analysis. # Read and interpolate GRACE loading model # Subtract the GRACE model # Remove a trend from the GPS data # Return the object. filename = grace_dir + "scaled_" + Data.name + "_PREM_model_ts.txt"; if not os.path.isfile(filename): print("Error! GRACE not found for %s" % Data.name); print("Returning placeholder object."); wimpyObj = get_wimpy_object(Data) return wimpyObj, wimpyObj; # If the station has been pre-computed with GRACE: Data = gps_ts_functions.remove_nans(Data); [grace_model] = gps_io_functions.read_grace(filename); my_paired_ts = grace_ts_functions.pair_GPSGRACE(Data, grace_model); decyear = gps_ts_functions.get_float_times(my_paired_ts.dtarray); # Subtract the GRACE object dE_filt, dN_filt, dU_filt = [], [], []; for i in range(len(my_paired_ts.dtarray)): dE_filt.append(my_paired_ts.east[i] - my_paired_ts.u[i]); dN_filt.append(my_paired_ts.north[i] - my_paired_ts.v[i]); dU_filt.append(my_paired_ts.vert[i] - my_paired_ts.w[i]); # A Simple detrending dE_detrended = np.zeros(np.shape(decyear)); dN_detrended = np.zeros(np.shape(decyear)); dU_detrended = np.zeros(np.shape(decyear)); east_coef = np.polyfit(decyear, dE_filt, 1)[0]; for i in range(len(dE_filt)): dE_detrended[i] = dE_filt[i] - east_coef * decyear[i] - (dE_filt[0] - east_coef * decyear[0]); north_coef = np.polyfit(decyear, dN_filt, 1)[0]; for i in range(len(dN_filt)): dN_detrended[i] = (dN_filt[i] - north_coef * decyear[i]) - (dN_filt[0] - north_coef * decyear[0]); vert_coef = np.polyfit(decyear, dU_filt, 1)[0]; for i in range(len(dU_filt)): dU_detrended[i] = (dU_filt[i] - vert_coef * decyear[i]) - (dU_filt[0] - vert_coef * decyear[0]); detrended = gps_io_functions.Timeseries(name=Data.name, coords=Data.coords, dtarray=my_paired_ts.dtarray, dN=dN_detrended, dE=dE_detrended, dU=dU_detrended, Sn=my_paired_ts.N_err, Se=my_paired_ts.E_err, Su=my_paired_ts.V_err, EQtimes=Data.EQtimes); trended = gps_io_functions.Timeseries(name=Data.name, coords=Data.coords, dtarray=my_paired_ts.dtarray, dN=dN_filt, dE=dE_filt, dU=dU_filt, Sn=my_paired_ts.N_err, Se=my_paired_ts.E_err, Su=my_paired_ts.V_err, EQtimes=Data.EQtimes); return detrended, trended; # 0 = successful completion
def remove_seasonals_by_german_load(Data, lsdm_dir): station = Data.name; files = glob.glob(lsdm_dir + station + '*.txt'); if not files: # found an empty array print("Error! LSDM file not found for %s" % Data.name); print("Returning placeholder object."); wimpyObj = get_wimpy_object(Data); return wimpyObj, wimpyObj; else: filename = files[0]; # Read the hydro model and pair it to the GPS [hydro_data] = gps_io_functions.read_lsdm_file(filename); # Clean up and pair data Data = gps_ts_functions.remove_nans(Data); hydro_data = gps_ts_functions.remove_nans(hydro_data); # this may or may not be necessary. [gps_data, hydro_data] = gps_ts_functions.pair_gps_model(Data, hydro_data); # matched in terms of dtarray. # Subtract the model from the data. dE_filt, dN_filt, dU_filt = [], [], []; for i in range(len(gps_data.dtarray)): dE_filt.append(gps_data.dE[i] - hydro_data.dE[i]); dN_filt.append(gps_data.dN[i] - hydro_data.dN[i]); dU_filt.append(gps_data.dU[i] - hydro_data.dU[i]); # A Simple detrending decyear = gps_ts_functions.get_float_times(gps_data.dtarray); dE_detrended = np.zeros(np.shape(decyear)); dN_detrended = np.zeros(np.shape(decyear)); dU_detrended = np.zeros(np.shape(decyear)); east_coef = np.polyfit(decyear, dE_filt, 1)[0]; for i in range(len(dE_filt)): dE_detrended[i] = dE_filt[i] - east_coef * decyear[i] - (dE_filt[0] - east_coef * decyear[0]); north_coef = np.polyfit(decyear, dN_filt, 1)[0]; for i in range(len(dN_filt)): dN_detrended[i] = (dN_filt[i] - north_coef * decyear[i]) - (dN_filt[0] - north_coef * decyear[0]); vert_coef = np.polyfit(decyear, dU_filt, 1)[0]; for i in range(len(dU_filt)): dU_detrended[i] = (dU_filt[i] - vert_coef * decyear[i]) - (dU_filt[0] - vert_coef * decyear[0]); detrended = gps_io_functions.Timeseries(name=gps_data.name, coords=gps_data.coords, dtarray=gps_data.dtarray, dE=dE_detrended, dN=dN_detrended, dU=dU_detrended, Se=gps_data.Se, Sn=gps_data.Sn, Su=gps_data.Su, EQtimes=gps_data.EQtimes); trended = gps_io_functions.Timeseries(name=gps_data.name, coords=gps_data.coords, dtarray=gps_data.dtarray, dE=dE_filt, dN=dN_filt, dU=dU_filt, Se=gps_data.Se, Sn=gps_data.Sn, Su=gps_data.Su, EQtimes=gps_data.EQtimes); return detrended, trended;
def remove_seasonals_by_lakes(Data, lakes_dir, lake_name): station = Data.name; files = glob.glob(lakes_dir + station + "_" + lake_name + "*.txt"); if not files: # found an empty array print("Error! Lake %s file not found for %s" % (lake_name, Data.name)); print("Returning placeholder object."); wimpyObj = get_wimpy_object(Data); return wimpyObj, wimpyObj; else: filename = files[0]; print("Reading loading TS from %s " % filename); loading_ts = read_loading_ts(filename); [GPS_paired, loading_paired] = gps_ts_functions.pair_gps_model(Data, loading_ts); dE = [GPS_paired.dE[i] - loading_paired.dE[i] for i in range(len(GPS_paired.dE))]; dN = [GPS_paired.dN[i] - loading_paired.dN[i] for i in range(len(GPS_paired.dN))]; dU = [GPS_paired.dU[i] - loading_paired.dU[i] for i in range(len(GPS_paired.dU))]; decyear = gps_ts_functions.get_float_times(GPS_paired.dtarray); dE_detrended = np.zeros(np.shape(dE)); dN_detrended = np.zeros(np.shape(dN)); dU_detrended = np.zeros(np.shape(dU)); east_coef = np.polyfit(decyear, dE, 1)[0]; for i in range(len(dE)): dE_detrended[i] = dE[i] - east_coef * decyear[i] - (dE[0] - east_coef * decyear[0]); north_coef = np.polyfit(decyear, dN, 1)[0]; for i in range(len(dN)): dN_detrended[i] = (dN[i] - north_coef * decyear[i]) - (dN[0] - north_coef * decyear[0]); vert_coef = np.polyfit(decyear, dU, 1)[0]; for i in range(len(dU)): dU_detrended[i] = (dU[i] - vert_coef * decyear[i]) - (dU[0] - vert_coef * decyear[0]); corrected_object = gps_io_functions.Timeseries(name=Data.name, coords=Data.coords, dtarray=GPS_paired.dtarray, dE=dE_detrended, dN=dN_detrended, dU=dU_detrended, Se=GPS_paired.Se, Sn=GPS_paired.Sn, Su=GPS_paired.Su, EQtimes=Data.EQtimes); trended = gps_io_functions.Timeseries(name=Data.name, coords=Data.coords, dtarray=GPS_paired.dtarray, dE=dE, dN=dN, dU=dU, Se=GPS_paired.Se, Sn=GPS_paired.Sn, Su=GPS_paired.Su, EQtimes=Data.EQtimes); return corrected_object, trended;
def remove_seasonals_by_hydro(Data, hydro_dir, scaling=False): station = Data.name; files = glob.glob(hydro_dir + station.lower() + '*.hyd'); if not files: # found an empty array print("Error! Hydro file not found for %s" % Data.name); print("Returning placeholder object."); wimpyObj = get_wimpy_object(Data); return wimpyObj, wimpyObj; else: filename = files[0]; # Read the hydro model and pair it to the GPS [hydro_data] = gps_io_functions.read_pbo_hydro_file(filename); # Clean up and pair data Data = gps_ts_functions.remove_nans(Data); # hydro_data=gps_ts_functions.remove_nans(hydro_data); # this may or may not be necessary. [gps_data, hydro_data] = gps_ts_functions.pair_gps_model(Data, hydro_data); # matched in terms of dtarray. if scaling is True: [_, _, vert_gps] = gps_ts_functions.get_linear_annual_semiannual(gps_data); [_, _, vert_hydro] = gps_ts_functions.get_linear_annual_semiannual(hydro_data); gps_amp = np.sqrt(vert_gps[1] * vert_gps[1] + vert_gps[2] * vert_gps[2]); hydro_amp = np.sqrt(vert_hydro[1] * vert_hydro[1] + vert_hydro[2] * vert_hydro[2]); if hydro_amp == 0.0: print("ERROR! NLDAS amplitude is exactly 0!! You should probably fix this. "); wimpyObj = get_wimpy_object(Data); print("Returning placeholder object."); return wimpyObj, wimpyObj; scale_factor = gps_amp / hydro_amp; # print("GPS Amplitude is %.2f mm" % gps_amp); # print("NLDAS Amplitude is %.2f mm" % hydro_amp); print("NLDAS scaling factor is %.2f" % scale_factor); else: scale_factor = 1; # Subtract the model from the data. dE_filt, dN_filt, dU_filt = [], [], []; for i in range(len(gps_data.dtarray)): dE_filt.append(gps_data.dE[i] - scale_factor * hydro_data.dE[i]); dN_filt.append(gps_data.dN[i] - scale_factor * hydro_data.dN[i]); dU_filt.append(gps_data.dU[i] - scale_factor * hydro_data.dU[i]); # A Simple detrending decyear = gps_ts_functions.get_float_times(gps_data.dtarray); dE_detrended = np.zeros(np.shape(decyear)); dN_detrended = np.zeros(np.shape(decyear)); dU_detrended = np.zeros(np.shape(decyear)); east_coef = np.polyfit(decyear, dE_filt, 1)[0]; for i in range(len(dE_filt)): dE_detrended[i] = dE_filt[i] - east_coef * decyear[i] - (dE_filt[0] - east_coef * decyear[0]); north_coef = np.polyfit(decyear, dN_filt, 1)[0]; for i in range(len(dN_filt)): dN_detrended[i] = (dN_filt[i] - north_coef * decyear[i]) - (dN_filt[0] - north_coef * decyear[0]); vert_coef = np.polyfit(decyear, dU_filt, 1)[0]; for i in range(len(dU_filt)): dU_detrended[i] = (dU_filt[i] - vert_coef * decyear[i]) - (dU_filt[0] - vert_coef * decyear[0]); corrected_object = gps_io_functions.Timeseries(name=gps_data.name, coords=gps_data.coords, dtarray=gps_data.dtarray, dE=dE_detrended, dN=dN_detrended, dU=dU_detrended, Se=gps_data.Se, Sn=gps_data.Sn, Su=gps_data.Su, EQtimes=gps_data.EQtimes); trended = gps_io_functions.Timeseries(name=gps_data.name, coords=gps_data.coords, dtarray=gps_data.dtarray, dE=dE_filt, dN=dN_filt, dU=dU_filt, Se=gps_data.Se, Sn=gps_data.Sn, Su=gps_data.Su, EQtimes=gps_data.EQtimes); return corrected_object, trended;
def remove_seasonals_by_STL(Data, STL_dir): # Has an issue: Not sure if it returns trended data. # Right now only returns detrended data. filename = STL_dir + Data.name + "_STL_30.txt"; if os.path.isfile(filename): # If a precomputed file exists... [dtstrings, dE, dN, dU, Se, Sn, Su] = np.loadtxt(filename, unpack=True, usecols=(0, 1, 2, 3, 4, 5, 6), dtype={'names': ('dt', 'dE', 'dN', 'dU', 'Se', 'Sn', 'Su'), 'formats': ('U8', np.float, np.float, np.float, np.float, np.float, np.float)}); final_dtarray = [dt.datetime.strptime(x, "%Y%m%d") for x in dtstrings]; Data = gps_io_functions.Timeseries(name=Data.name, coords=Data.coords, dtarray=final_dtarray, dN=dN, dE=dE, dU=dU, Sn=Sn, Se=Se, Su=Su, EQtimes=Data.EQtimes); else: # ELSE: WE NEED TO RECOMPUTE print("Warning! STL not found for %s" % Data.name); print("We did not find a pre-computed array, so we are re-computing STL. "); # Preprocess data: remove nans, fill in gaps. Data = gps_ts_functions.remove_nans(Data); [_, dE, Se] = preprocess_stl(Data.dtarray, Data.dE, Data.Se); [_, dN, Sn] = preprocess_stl(Data.dtarray, Data.dN, Data.Sn); [new_dtarray, dU, Su] = preprocess_stl(Data.dtarray, Data.dU, Data.Su); # Write E, N, U ofile = open('raw_ts_data.txt', 'w'); for i in range(len(dE)): mystring = dt.datetime.strftime(new_dtarray[i], "%Y%m%d"); ofile.write('%s %f %f %f\n' % (mystring, dE[i], dN[i], dU[i])); ofile.close(); # Call driver in matlab (read, STL, write) subprocess.call(['matlab', '-nodisplay', '-nosplash', '-r', 'stl_driver'], shell=False); # Read / Detrended data [dE, dN, dU] = np.loadtxt('filtered_ts_data.txt', unpack=True, usecols=(1, 2, 3)); # East, North, Up Detrending decyear = gps_ts_functions.get_float_times(new_dtarray); dE_detrended = np.zeros(np.shape(dE)); dN_detrended = np.zeros(np.shape(dN)); dU_detrended = np.zeros(np.shape(dU)); east_coef = np.polyfit(decyear, dE, 1)[0]; for i in range(len(dE)): dE_detrended[i] = dE[i] - east_coef * decyear[i] - (dE[0] - east_coef * decyear[0]); north_coef = np.polyfit(decyear, dN, 1)[0]; for i in range(len(dN)): dN_detrended[i] = (dN[i] - north_coef * decyear[i]) - (dN[0] - north_coef * decyear[0]); vert_coef = np.polyfit(decyear, dU, 1)[0]; for i in range(len(dU)): dU_detrended[i] = (dU[i] - vert_coef * decyear[i]) - (dU[0] - vert_coef * decyear[0]); # Put the gaps back in: final_dtarray, final_dE, final_dN, final_dU = [], [], [], []; final_Se, final_Sn, final_Su = [], [], []; for i in range(len(new_dtarray)): if new_dtarray[i] in Data.dtarray: final_dtarray.append(new_dtarray[i]); final_dE.append(dE_detrended[i]); final_dN.append(dN_detrended[i]); final_dU.append(dU_detrended[i]); final_Se.append(Se[i]); final_Sn.append(Sn[i]); final_Su.append(Su[i]); final_dE = np.array(final_dE); final_dN = np.array(final_dN); final_dU = np.array(final_dU); final_Se = np.array(final_Se); final_Sn = np.array(final_Sn); final_Su = np.array(final_Su); # Return data Data = gps_io_functions.Timeseries(name=Data.name, coords=Data.coords, dtarray=final_dtarray, dN=final_dN, dE=final_dE, dU=final_dU, Sn=final_Sn, Se=final_Se, Su=final_Su, EQtimes=Data.EQtimes); # Write the file so that we don't recompute it next time. output_stl(Data, STL_dir); return Data, Data;
def remove_seasonals_by_GRACE(Data, grace_dir): # Here we use pre-computed GRACE load model time series to correct the GPS time series. # We recognize that the horizontals will be bad, and that the resolution of GRACE is coarse. # For these reasons, this is not an important part of the analysis. # Read and interpolate GRACE loading model # Subtract the GRACE model # Remove a trend from the GPS data # Return the object. filename = grace_dir + "scaled_" + Data.name + "_PREM_model_ts.txt" try: ifile = open(filename) except FileNotFoundError: print("Error! GRACE not found for %s" % Data.name) placeholder = np.full_like(Data.dtarray, np.nan, dtype=np.double) wimpyObj = Timeseries(name=Data.name, coords=Data.coords, dtarray=Data.dtarray, dN=[1.0000], dE=placeholder, dU=placeholder, Sn=Data.Sn, Se=Data.Se, Su=Data.Su, EQtimes=Data.EQtimes) print("returning placeholder object") return wimpyObj # 1 = error code. # If the station has been pre-computed with GRACE: Data = gps_ts_functions.remove_nans(Data) grace_model = grace_ts_functions.input_GRACE_individual_station( grace_dir + "scaled_" + Data.name + "_PREM_model_ts.txt") my_paired_ts = grace_ts_functions.pair_GPSGRACE(Data, grace_model) decyear = gps_ts_functions.get_float_times(my_paired_ts.dtarray) # Subtract the GRACE object dE_filt = [] dN_filt = [] dU_filt = [] for i in range(len(my_paired_ts.dtarray)): dE_filt.append(my_paired_ts.east[i] - my_paired_ts.u[i]) dN_filt.append(my_paired_ts.north[i] - my_paired_ts.v[i]) dU_filt.append(my_paired_ts.vert[i] - my_paired_ts.w[i]) # A Simple detrending dE_detrended = np.zeros(np.shape(decyear)) dN_detrended = np.zeros(np.shape(decyear)) dU_detrended = np.zeros(np.shape(decyear)) east_coef = np.polyfit(decyear, dE_filt, 1)[0] for i in range(len(dE_filt)): dE_detrended[i] = dE_filt[i] - east_coef * decyear[i] - ( dE_filt[0] - east_coef * decyear[0]) north_coef = np.polyfit(decyear, dN_filt, 1)[0] for i in range(len(dN_filt)): dN_detrended[i] = (dN_filt[i] - north_coef * decyear[i]) - ( dN_filt[0] - north_coef * decyear[0]) vert_coef = np.polyfit(decyear, dU_filt, 1)[0] for i in range(len(dU_filt)): dU_detrended[i] = (dU_filt[i] - vert_coef * decyear[i]) - ( dU_filt[0] - vert_coef * decyear[0]) newData = Timeseries(name=Data.name, coords=Data.coords, dtarray=my_paired_ts.dtarray, dN=dN_detrended, dE=dE_detrended, dU=dU_detrended, Sn=my_paired_ts.N_err, Se=my_paired_ts.E_err, Su=my_paired_ts.V_err, EQtimes=Data.EQtimes) return newData
def remove_seasonals_by_STL(Data, STL_dir): # First check if a pre-computed file exists filename = STL_dir + Data.name + "_STL_30.txt" recompute = 0 try: ifile = open(filename) except FileNotFoundError: print("Warning! STL not found for %s" % Data.name) recompute = 1 if recompute == 0: # If a precomputed file exists... [dE, dN, dU, Se, Sn, Su] = np.loadtxt(filename, unpack=True, usecols=(1, 2, 3, 4, 5, 6)) final_dtarray = [] for line in ifile: dtstring = line.split()[0] final_dtarray.append(dt.datetime.strptime(dtstring, "%Y%m%d")) Data = Timeseries(name=Data.name, coords=Data.coords, dtarray=final_dtarray, dN=dN, dE=dE, dU=dU, Sn=Sn, Se=Se, Su=Su, EQtimes=Data.EQtimes) # ELSE: WE NEED TO RECOMPUTE else: print( "We did not find a pre-computed array, so we are re-computing STL. " ) # Preprocess data: remove nans, fill in gaps. Data = gps_ts_functions.remove_nans(Data) [new_dtarray, dE, Se] = preprocess_stl(Data.dtarray, Data.dE, Data.Se) [new_dtarray, dN, Sn] = preprocess_stl(Data.dtarray, Data.dN, Data.Sn) [new_dtarray, dU, Su] = preprocess_stl(Data.dtarray, Data.dU, Data.Su) # Write E, N, U ofile = open('raw_ts_data.txt', 'w') for i in range(len(dE)): mystring = dt.datetime.strftime(new_dtarray[i], "%Y%m%d") ofile.write('%s %f %f %f\n' % (mystring, dE[i], dN[i], dU[i])) ofile.close() # Call driver in matlab (read, STL, write) subprocess.call( ['matlab', '-nodisplay', '-nosplash', '-r', 'stl_driver'], shell=False) # Read / Detrended data [dE, dN, dU] = np.loadtxt('filtered_ts_data.txt', unpack=True, usecols=(1, 2, 3)) # East, North, Up Detrending decyear = gps_ts_functions.get_float_times(new_dtarray) dE_detrended = np.zeros(np.shape(dE)) dN_detrended = np.zeros(np.shape(dN)) dU_detrended = np.zeros(np.shape(dU)) east_coef = np.polyfit(decyear, dE, 1)[0] for i in range(len(dE)): dE_detrended[i] = dE[i] - east_coef * decyear[i] - ( dE[0] - east_coef * decyear[0]) north_coef = np.polyfit(decyear, dN, 1)[0] for i in range(len(dN)): dN_detrended[i] = (dN[i] - north_coef * decyear[i]) - ( dN[0] - north_coef * decyear[0]) vert_coef = np.polyfit(decyear, dU, 1)[0] for i in range(len(dU)): dU_detrended[i] = (dU[i] - vert_coef * decyear[i]) - ( dU[0] - vert_coef * decyear[0]) # Put the gaps back in: final_dtarray = [] final_dE = [] final_dN = [] final_dU = [] final_Se = [] final_Sn = [] final_Su = [] for i in range(len(new_dtarray)): if new_dtarray[i] in Data.dtarray: final_dtarray.append(new_dtarray[i]) final_dE.append(dE_detrended[i]) final_dN.append(dN_detrended[i]) final_dU.append(dU_detrended[i]) final_Se.append(Se[i]) final_Sn.append(Sn[i]) final_Su.append(Su[i]) final_dE = np.array(final_dE) final_dN = np.array(final_dN) final_dU = np.array(final_dU) final_Se = np.array(final_Se) final_Sn = np.array(final_Sn) final_Su = np.array(final_Su) # Return data Data = Timeseries(name=Data.name, coords=Data.coords, dtarray=final_dtarray, dN=final_dN, dE=final_dE, dU=final_dU, Sn=final_Sn, Se=final_Se, Su=final_Su, EQtimes=Data.EQtimes) # Write the file so that we don't recompute it next time. output_stl(Data, STL_dir) return Data