示例#1
0
 g_working.data = g.data[start_idx:end_idx].copy()
 g_working.time = g.time[start_idx:end_idx].copy()
 if np.all(np.isnan(g_working.data) == False):
     wave, _, _, _ = wavelet_analysis.continous_wavelet(
         g_working.data,
         1,
         False,
         wavelet_analysis.morlet,
         dj=0,
         s0=s0,
         j1=0,
         k0=k0)  # perform wavelet
     phase = np.arctan2(np.imag(wave),
                        np.real(wave))  # get phases from oscillatory modes
     start_cut = date(start_year + cnt * WINDOW_SHIFT, sm, sd)
     idx = g_working.get_data_of_precise_length(WINDOW_LENGTH, start_cut,
                                                None, True)  # 16k or 13462
     print 'data ', g.get_date_from_ndx(
         start_idx), ' - ', g.get_date_from_ndx(end_idx)
     print 'cut from ', start_cut, ' to ', g_working.get_date_from_ndx(-1)
     last_mid_year = date.fromordinal(g_working.time[WINDOW_LENGTH /
                                                     2]).year
     phase = phase[0, idx[0]:idx[1]]
     phase_bins = get_equidistant_bins()  # equidistant bins
     for i in range(cond_means.shape[0]
                    ):  # get conditional means for current phase range
         ndx = ((phase >= phase_bins[i]) & (phase <= phase_bins[i + 1]))
         if MEANS:
             cond_means[i] = np.mean(g_working.data[ndx])
         else:
             cond_means[i] = np.var(g_working.data[ndx], ddof=1)
     difference_data.append(cond_means.max() -
示例#2
0
            period = PERIOD * year  # frequency of interest
            s0 = period / fourier_factor  # get scale
            wave, _, _, _ = wvlt.continous_wavelet(g_temp.data,
                                                   1,
                                                   False,
                                                   wvlt.morlet,
                                                   dj=0,
                                                   s0=s0,
                                                   j1=0,
                                                   k0=k0)  # perform wavelet
            phase = np.arctan2(
                np.imag(wave),
                np.real(wave))  # get phases from oscillatory modes

            idx = g_temp.get_data_of_precise_length(WINDOW_LENGTH,
                                                    date(sy, sm, sd), None,
                                                    True)
            phase = phase[0, idx[0]:idx[1]]
            tg_temp = tg_temp[idx[0]:idx[1]]

            sigma = np.std(tg_temp, axis=0, ddof=1)

            for i in range(phase_bins.shape[0] - 1):
                ndx = ((phase >= phase_bins[i]) & (phase <= phase_bins[i + 1]))
                data_temp = g_temp.data[ndx].copy()
                time_temp = g_temp.time[ndx].copy()
                tg_sat_temp = tg_temp[ndx].copy()

                # positive extremes
                g_e = np.greater_equal(tg_sat_temp,
                                       np.mean(tg_temp, axis=0) + 2 * sigma)
        if AMPLITUDE:
            wave, _, _, _ = wavelet_analysis.continous_wavelet(
                g_working_amp.data, 1, False, wavelet_analysis.morlet, dj=0, s0=s0_amp, j1=0, k0=k0
            )  # perform wavelet
            amplitude = np.sqrt(np.power(np.real(wave), 2) + np.power(np.imag(wave), 2))
            amplitude = amplitude[0, :]
            phase_amp = np.arctan2(np.imag(wave), np.real(wave))
            phase_amp = phase_amp[0, :]
            reconstruction = amplitude * np.cos(phase_amp)
            fit_x = np.vstack([reconstruction, np.ones(reconstruction.shape[0])]).T
            m, c = np.linalg.lstsq(fit_x, g_working_amp.data)[0]
            amplitude = m * amplitude + c

        start_cut = date(start_year + cnt * WINDOW_SHIFT, sm, sd)
        idx = g_working.get_data_of_precise_length(WINDOW_LENGTH, start_cut, None, True)
        print "data ", g.get_date_from_ndx(start_idx), " - ", g.get_date_from_ndx(end_idx)
        print "cut from ", start_cut, " to ", g_working.get_date_from_ndx(-1)
        # last_mid_year = date.fromordinal(g_working.time[WINDOW_LENGTH/2]).year
        last_mid_year += 1
        print last_mid_year
        phase = phase[0, idx[0] : idx[1]]
        if AMPLITUDE:
            amplitude = amplitude[idx[0] : idx[1]]
        if PLOT_PHASE and BEGIN:
            phase_till = date(start_year + (cnt + 1) * WINDOW_SHIFT, sm, sd)
            ndx = g_working.find_date_ndx(phase_till)
            if ndx != None and cnt < 125:
                phase_total.append(phase[:ndx])
            else:
                phase_total.append(phase)
示例#4
0
  g_temp.time = g.time.copy()
  start = g_temp.find_date_ndx(date(sy - 4, sm, sd))
  end = start + 16384 if WINDOW_LENGTH < 16000 else start + 32768
 
  g_temp.data = g_temp.data[start : end]
  g_temp.time = g_temp.time[start : end]
  tg_temp = tg_temp[start : end]
  
  k0 = 6. # wavenumber of Morlet wavelet used in analysis
  fourier_factor = (4 * np.pi) / (k0 + np.sqrt(2 + np.power(k0,2)))
  period = PERIOD * year # frequency of interest
  s0 = period / fourier_factor # get scale
  wave, _, _, _ = wvlt.continous_wavelet(g_temp.data, 1, False, wvlt.morlet, dj = 0, s0 = s0, j1 = 0, k0 = k0) # perform wavelet
  phase = np.arctan2(np.imag(wave), np.real(wave)) # get phases from oscillatory modes
  
  idx = g_temp.get_data_of_precise_length(WINDOW_LENGTH, date(sy, sm, sd), None, True)
  phase = phase[0, idx[0] : idx[1]]
  tg_temp = tg_temp[idx[0] : idx[1]]
  
  sigma = np.std(tg_temp, axis = 0, ddof = 1)
  
  
  for i in range(phase_bins.shape[0] - 1):
      ndx = ((phase >= phase_bins[i]) & (phase <= phase_bins[i+1]))
      data_temp = g_temp.data[ndx].copy()
      time_temp = g_temp.time[ndx].copy()
      tg_sat_temp = tg_temp[ndx].copy()
      
      # positive extremes
      g_e = np.greater_equal(tg_sat_temp, np.mean(tg_temp, axis = 0) + 2 * sigma)
      result_temp_surr[surr, i, 0] = np.sum(g_e)