Пример #1
0
    def plot(self, *args, **kwargs):
        tss = self.eval()
        if 'ax' in kwargs: ax = kwargs['ax']
	else:              ax = gca()
        if 'R' in self.axis:
            kwargsr       = kwargs.copy()    
            kwargsr['ax'] = ax.twinx()
        for ts,h,a in zip(tss, self.hidden, self.axis):
	    if not h and type(ts) != type(''):
                if a!='R':
		    kw = kwargs.copy()
                    #ts.plot(*args, **kwargs)
                else:
		    kw = kwargsr.copy()
		    l  = ax.plot([],label=ts.name)
		    kw['color'] = l[0].get_color()
		if a=='V':
		    if ts[0] != 0: ds = [ts.index[0]]
		    else:          ds = []
		    for d, x, lx in zip(ts.index, ts, ts.shift(1))[1:]:
			if (x==0) != (lx==0): ds.append(d)
		    if len(ds) % 2 != 0:
			ds.append(es[1].index[-1])
		    it = iter(ds)
		    for pair in izip(it,it):
			x1=date2num(pair[0])
			x2=date2num(pair[1])
			ax.axvspan(x1,x2, facecolor='b', alpha=0.16)
		else:
		    kw['label'] = ts.name
		    ts.dropna().plot(*args, **kw)
Пример #2
0
    def autoscale(self):
        """
        Set the view limits to include the data range.
        """
        dmin, dmax = self.datalim_to_dt()
        if dmin > dmax:
            dmax, dmin = dmin, dmax

        delta = relativedelta(dmax, dmin)

        # We need to cap at the endpoints of valid datetime
        try:
            start = dmin - delta
        except ValueError:
            start = _from_ordinal(1.0)

        try:
            stop = dmax + delta
        except ValueError:
            # The magic number!
            stop = _from_ordinal(3652059.9999999)

        dmin, dmax = self.datalim_to_dt()

        vmin = dates.date2num(dmin)
        vmax = dates.date2num(dmax)

        return self.nonsingular(vmin, vmax)
def plot_date_bars(bin_data, bin_edges, title, ylabel, fname):
    """
    Semi-generic function to plot a bar graph, x-label is fixed to "date" and the
    x-ticks are formatted accordingly.

    To plot a histogram, the histogram data must be calculated manually outside
    this function, either manually or using :py:func`numpy.histogram`.

    :param bin_data: list of data for each bin
    :param bin_edges: list of bin edges (:py:class:`datetime.date` objects), its
                      length must be ``len(data)+1``
    :param title: title of the plot
    :param ylabel: label of y-axis
    :param fname: output file name
    """
    import matplotlib.pyplot as plt
    from matplotlib.dates import date2num, num2date
    from matplotlib import ticker

    plt.figure()  # clear previous figure
    plt.title(title)
    plt.xlabel("date")
    plt.ylabel(ylabel)

    # plot the bars, width of the bins is assumed to be fixed
    plt.bar(date2num(bin_edges[:-1]), bin_data, width=date2num(bin_edges[1]) - date2num(bin_edges[0]))

    # x-ticks formatting
    plt.gca().xaxis.set_major_formatter(ticker.FuncFormatter(lambda numdate, _: num2date(numdate).strftime('%Y-%m-%d')))
    plt.gcf().autofmt_xdate()
    plt.tick_params(axis="x", which="both", direction="out")
    plt.xticks([date2num(ts) for ts in bin_edges if ts.month % 12 == 1])

    plt.savefig(fname, papertype="a4")
Пример #4
0
    def calc_bar_colors(measure, end_date, is_planning):
        """Returns calculated bars. The bars are aggregated from
        measure_status_moments from sub measures.

        ** measure can also be a measure_collection. It uses the
           status_moment function only.
        """
        measure_bar = []
        measure_colors = []
        measure_status_moments = measure.measure_status_moments(
            end_date=end_date, is_planning=is_planning)
        for msm_index, msm in enumerate(measure_status_moments):
            # drawing enddate: "infinity" or next status moment
            if msm_index == len(measure_status_moments) - 1:
                msm_end_date = end_date
            else:
                if is_planning:
                    msm_end_date = measure_status_moments[
                        msm_index + 1].planning_date
                else:
                    msm_end_date = measure_status_moments[
                        msm_index + 1].realisation_date

            if is_planning:
                begin = msm.planning_date
            else:
                begin = msm.realisation_date
            date_length = date2num(msm_end_date) - date2num(begin)

            measure_bar.append((date2num(begin), date_length))
            measure_colors.append(msm.status.color.html)
        return measure_bar, measure_colors
Пример #5
0
def plotAotiHour():

    fig = plt.figure(figsize=(18, 5))
    rect = fig.patch
    rect.set_facecolor("white")
    df = pd.read_csv("urban-country/aoti_pm25.csv", sep=",", header=0)
    df = df[df["date"] >= 20140514]
    df = df[df["date"] <= 20140527]
    df["date"] = df["date"].astype(str)
    df["hour"] = df["hour"].astype(str)
    dateAndTime = pd.to_datetime(df["date"] + df["hour"], format="%Y%m%d%H")
    aoti = df["奥体中心"].tolist()
    ts_aoti = Series(aoti, index=dateAndTime)
    plot = ts_aoti.plot(linestyle="-", color="black", marker="8", markersize=4, label=u"奥体中心")
    time = dt.datetime(2014, 05, 17, 10)
    df = df[df["date"] == "20140517"]
    df = df[df["hour"] == "10"]
    value = df.iloc[0, 3]
    print mdates.date2num(time), value
    plt.annotate(
        u"aoti24",
        xy=(mdates.date2num(time), value),
        xytext=(30, 20),
        textcoords="offset points",
        arrowprops=dict(arrowstyle="-|>"),
    )
    plt.show()
Пример #6
0
def plot(startday, filename, col1, col2, col3):
    now = datetime.now()
    now = time.mktime(now.timetuple())
    df = pd.read_csv(filename,delimiter='\t',index_col=0)
    df = df.dropna(axis=0)
    plt.subplot(211)
    if startday < 0:
        startindex = 0
    else:
        startindex = df['date'].searchsorted(now - startday * 24 * 3600)[0]
    print startindex
    df['date'] = df['date'].apply(lambda x:mdates.date2num(convert_to_localtime(x)))
    #plt.bar(df.iloc[::][col1],df.iloc[::][col2],color='black')
    plt.hist(df.iloc[startindex:][col2], [-1,0,1,2],color='black')
    plt.subplot(212)
#    ax.set_ylim(0,100000)
#    ax2 = plt.subplot(212,sharex=ax)
    plt.scatter(df.iloc[::][col1],df.iloc[::][col3],color='blue')
    xrange1 = mdates.date2num(convert_to_localtime(now-startday*24*3600))
    xrange2 = mdates.date2num(convert_to_localtime(now))
#    plt.xlim(xrange1, xrange2)
#    plt.ylim(7500,12000)
#    ax.axis.set_major_formatter(mdates.DateFormatter('%m-%d %H:%M'))
    plt.grid(True)
#    for label in ax2.xaxis.get_ticklabels():
#        label.set_rotation(45)
    plt.subplots_adjust(left=0.09, bottom=0.2, right=0.94, top=0.90, wspace=0.12, hspace=0)
    plt.show()
Пример #7
0
def plot_chart(*tfs, norm=True, realtime=True, markers = None):
    import matplotlib.dates as mdt
    fig, ax = plt.subplots()
    if len(tfs) == 1 and norm is True:
        y = [(mdt.date2num(candle.DateTime), candle.Open, candle.Close, candle.High, candle.Low) for candle in tfs[0].container]
        candlestick(ax, y, width=0.4, colorup='r', colordown='b')
        ax.xaxis_date()
        plt.title(tfs[0].symbol + " chart")
        if markers is not None:
            marker_y, marker_x = [], []
            for elem in tfs[0].container:
                if elem.DateTime in markers:
                    marker_y.append(.5*(elem.Open+elem.Close))
                    marker_x.append(mdt.date2num(elem.DateTime))
            plt.plot(marker_x, marker_y, 'gD')
    else:
        for tf in tfs:
            if realtime is True:
                x = tf.get_Time_list()
            else:
                x = range(len(tf))
            y = np.array(tf.get_C_list())
            if norm is True:
                y -= y.min()
                y /= y.max()
            plt.plot(x, y, label=tf.symbol)
            plt.title("Charts graph")
    plt.legend(loc='upper center', shadow=True)
    plt.xlabel("Time")
    plt.ylabel("Price")
    plt.grid()
    plt.show()
    def __init__(self,fig):

        times,L,MLT,MLAT,InvLat,density=get_density_and_time('rbspa',datetime(2012,10,6),datetime(2012,10,10))
        otimes=date2num(times)

        timesb,Lb,MLTb,MLATb,InvLatb,densityb=get_density_and_time('rbspb',datetime(2012,10,8),datetime(2012,10,9))
        otimesb=date2num(timesb)

        self.L=L
        self.times=times
        self.otimes=otimes
        self.density=density

        self.emfisis_fit=emfisis_fit_model('rbspa')
        fitdensity,fituncert,inds=self.emfisis_fit(times,L,MLT,MLAT,InvLat,returnFull=True)
        self.fitdensity=fitdensity

        self.fig=fig
        self.ax1=plt.subplot(2,1,1)
        self.ax2=plt.subplot(2,1,2)

        self.ax2.plot(L,density,linestyle='',marker='.')

        self.Lline=None
        self.Llim=np.array([1.5,2])
        self.pressed=False

        self.uinds=np.unique(inds)
        self.uinds=self.uinds[self.uinds<self.emfisis_fit.fitcoeffs.shape[0]]

        self.fig.canvas.mpl_connect('motion_notify_event',self.select_L)
        self.fig.canvas.mpl_connect('button_press_event',self.select_Lstart)
        self.fig.canvas.mpl_connect('button_release_event',self.on_release)
Пример #9
0
    def handle(self, *args, **options):
        # Get user join dates
        User = get_user_model()
        datetimes = User.objects.values_list('date_joined', flat=True) \
                                .order_by('date_joined')
        dates = map(lambda d: d.date(), datetimes)

        # Get some auxilliary values
        min_date = date2num(dates[0])
        max_date = date2num(dates[-1])
        days = max_date - min_date + 1

        # Initialize X and Y axes
        x = np.arange(min_date, max_date + 1)
        y = np.zeros(days)

        # Iterate over dates, increase registration array
        for date in dates:
            index = int(date2num(date) - min_date)
            y[index] += 1
        y_sum = np.cumsum(y)

        # Plot
        plt.plot_date(x, y_sum, xdate=True, ydate=False, ls='-', ms=0, color='#16171E')
        plt.fill_between(x, 0, y_sum, facecolor='#D0F3FF')
        plt.title('Studentenportal: Registrierte Benutzer')
        plt.rc('font', size=8)
        if options['save']:
            plt.savefig(options['save'])
        else:
            plt.show()
Пример #10
0
    def on_loadQuoteClicked(self):
        logger.info('load quote')

        fileName = QtGui.QFileDialog.getOpenFileName(
            self, self.tr("Open Quote Data"), data_path,
            self.tr("Quote Files (*.csv)"))
        logger.info("Filename %s" % fileName)

        if os.path.isfile(fileName):
            df = pd.read_csv(unicode(fileName))
            df.columns = [col.lower() for col in df.columns]
            if 'datetime' in df.columns:
                df = df.sort(['datetime'])
                df['datetime'] = df.apply(
                    lambda row: mdates.date2num(parser.parse(row['datetime'])),
                    axis=1)
            elif 'date' in df.columns:
                df = df.sort(['date'])
                df['datetime'] = df.apply(
                    lambda row: mdates.date2num(parser.parse(row['date'])),
                    axis=1)

            if 'datetime' in df.columns and not df['datetime'].empty:
                self.ui_controller.matplotlibWidget.set_data(df)
                self.ui_controller.matplotlibWidget.draw_data()
            self.df = df
Пример #11
0
def parse_file_to_dict(data_dict, samp_int_dict, file, counter, format=None,
                       verbose=False, ignore_links=False):
    from matplotlib.dates import date2num
    if ignore_links and os.path.islink(file):
        print("Ignoring symlink: %s" % (file))
        return counter
    try:
        stream = read(file, format=format, headonly=True)
    except:
        print("Can not read %s" % (file))
        return counter
    s = "%s %s" % (counter, file)
    if verbose:
        sys.stdout.write("%s\n" % s)
        for line in str(stream).split("\n"):
            sys.stdout.write("    " + line + "\n")
    else:
        sys.stdout.write("\r" + s)
        sys.stdout.flush()
    for tr in stream:
        _id = tr.getId()
        data_dict.setdefault(_id, [])
        data_dict[_id].append([date2num(tr.stats.starttime),
                               date2num(tr.stats.endtime)])
        try:
            samp_int_dict.\
                setdefault(_id, 1. / (24 * 3600 * tr.stats.sampling_rate))
        except ZeroDivisionError:
            print("Skipping file with zero samlingrate: %s" % (file))
            return counter
    return (counter + 1)
Пример #12
0
def plot_temp():
    data = read_temps()
    dates, values = map(np.array, zip(*[(d['date'], d['temperature'])
                                        for d in data]))
    tmp = (date2num(dates) % 1.0)*24.0
    ii = np.where((tmp > 0) & (tmp < 8))[0]
    continuum = get_continuum(dates, dates[ii], values[ii])
    
    
    setup(figsize=(12,6))
    
    setupplot(subplt=(1,2,1), autoticks=True, xlabel='Date',)
    pylab.plot(dates, values)
    pylab.plot(dates[ii], values[ii], '.r')
    pylab.plot(dates, continuum, '.k')
    plot_weather(np.min(date2num(dates)))
    # pylab.plot(dates, values-continuum+38, '.r')
    dateticks('%Y.%m.%d')
    
    
    setupplot(subplt=(2,2,2), autoticks=False, xlabel='Hour of Day')
    pylab.plot(tmp, values, '.')
    setupplot(subplt=(2,2,2), ylabel='', secondax=True)
    
    setupplot(subplt=(2,2,4), autoticks=False, xlabel='Hour of Day')
    sc = pylab.scatter(tmp, values-continuum+TNORM, 
                       c=date2num(dates)-np.min(date2num(dates)), s=15,
                       marker='.', edgecolor='none',
                       label='Days since Start')
    
    setupplot(subplt=(2,2,4), ylabel='', secondax=True)
    hcolorbar(sc, axes=[0.75, 0.42, 0.1, 0.01])
    
    pylab.tight_layout()
    pylab.show()
Пример #13
0
def generate_count(counts):
    import matplotlib
    from matplotlib.pyplot import figure, show
    from matplotlib.dates import DateFormatter

    print len(counts)

    fig = figure()
    matplotlib.rcParams['font.size'] = 8.0
    ax = fig.add_subplot(111)
    ax.plot_date(counts.keys(),counts.values(), markersize=2)
    ax.set_title('Nb of actions per second')
    ax.set_ylabel('Nb of actions')
    ax.fmt_xdata = DateFormatter('%H:%M:%S')

    timestamp = counts.keys()[0]
    start = datetime.datetime(timestamp.year, timestamp.month, timestamp.day,7,0,0)
    end = datetime.datetime(timestamp.year, timestamp.month, timestamp.day,16,1,0)
    ax.set_xlim( date2num(start), date2num(end))

    fig.autofmt_xdate()
    fig.subplots_adjust(left=.05, bottom=.2, right=.95, top=.9)
    filename = 'action_count.png'
    fig.set_size_inches(10., 3.)

    fig.savefig(filename)
    return filename
Пример #14
0
def Hierro_ecvd(data_file):
    #Import catalogue in IGN fixed width text file format
    columns = [slice(5,12), slice(17,27), slice(34,42), slice(50,57), slice(64,75), slice(85,87), slice(114,117)]
    output = []

    myfile = open(data_file)
    for line in myfile:
        fields = [line[column].strip() for column in columns]
        output.append(fields)
    Cat1 = np.array(output)
    Cat1[Cat1==''] = 999
    y=Cat1[1:,3:].astype(np.float)
    x=Cat1[1:,1:3]


    dates =[]
    times = []
    for line in x:
        datevalues = mdates.date2num(dt.datetime.strptime(line[0], "%d/%m/%Y"))
        timevalues = mdates.date2num(dt.datetime.strptime(line[1], "%H:%M:%S"))-(mdates.date2num(dt.date(1900,01,01)))
        dates.append(datevalues)
        times.append(timevalues)

    datetimes = np.add(dates,times)
    datetimes = datetimes.reshape(len(dates),1)
    Cat1 = np.concatenate((datetimes,y), axis=1)
    Cat1 = Cat1[Cat1[:,0].argsort()]
    return Cat1
Пример #15
0
 def plot_trend_graph_all_tests(self, save_path='', file_name='_trend_graph.png'):
     time_format1 = '%d-%m-%Y-%H:%M'
     time_format2 = '%Y-%m-%d-%H:%M'
     for test in self.tests:
         test_data = test.results_df[test.results_df.columns[2]].tolist()
         test_time_stamps = test.results_df[test.results_df.columns[3]].tolist()
         start_date = test_time_stamps[0]
         test_time_stamps.append(self.end_date + '-23:59')
         test_data.append(test_data[-1])
         float_test_time_stamps = []
         for ts in test_time_stamps:
             try:
                 float_test_time_stamps.append(matdates.date2num(datetime.strptime(ts, time_format1)))
             except:
                 float_test_time_stamps.append(matdates.date2num(datetime.strptime(ts, time_format2)))
         plt.plot_date(x=float_test_time_stamps, y=test_data, label=test.name, fmt='.-', xdate=True)
         plt.legend(fontsize='small', loc='best')
     plt.ylabel('MPPS/Core (Norm)')
     plt.title('Setup: ' + self.name)
     plt.tick_params(
         axis='x',
         which='both',
         bottom='off',
         top='off',
         labelbottom='off')
     plt.xlabel('Time Period: ' + start_date[:-6] + ' - ' + self.end_date)
     if save_path:
         plt.savefig(os.path.join(save_path, self.name + file_name))
         if not self.setup_trend_stats.empty:
             (self.setup_trend_stats.round(2)).to_csv(os.path.join(save_path, self.name +
                                                                   '_trend_stats.csv'))
         plt.close('all')
Пример #16
0
    def get_local_historical_data_from_db(self, _symbol, _convert, _is_intraday):
        data = None

        if os.path.isfile(FILE_GENERATOR.format(DB_PATH, _symbol)):
            saved_data = open(FILE_GENERATOR.format(DB_PATH, _symbol), "r")
            data = saved_data.read().split("\n")

            date_data = []
            open_data = []
            high_data = []
            low_data = []
            close_data = []
            volume_data = []

            for line in data:
                splitted_line = line.split(",")

                datetime_to_float = splitted_line[0]
                if _convert:
                    if _is_intraday:
                        datetime_to_float = mdates.date2num(
                            datetime.datetime.strptime(splitted_line[0], "%Y-%m-%d %H:%M:%S")
                        )
                    else:
                        datetime_to_float = mdates.date2num(
                            datetime.datetime.strptime(splitted_line[0], "%Y-%m-%d").replace(
                                hour=16, minute=0, second=0
                            )
                        )
                date_data.append(datetime_to_float)

                open_to_float = float(splitted_line[1])
                open_data.append(open_to_float)

                high_to_float = float(splitted_line[2])
                high_data.append(high_to_float)

                low_to_float = float(splitted_line[3])
                low_data.append(low_to_float)

                close_to_float = float(splitted_line[4])
                close_data.append(close_to_float)

                volume_to_float = float(splitted_line[5])
                volume_data.append(volume_to_float)

            df = pd.DataFrame(np.array(date_data), columns=["Date"])
            if _is_intraday:
                df["Date"] = range(0, len(np.array(open_data)))
            df["Open"] = np.array(open_data)
            df["High"] = np.array(high_data)
            df["Low"] = np.array(low_data)
            df["Close"] = np.array(close_data)
            df["Volume"] = np.array(volume_data)
            # df.index = date_data
            if df.isnull().values.any():
                print "Erroneous data found in the db! It must be fixed manually!"
            return df
        else:
            print "{}: No db file for {}!".format(datetime.datetime.now(), _symbol)
Пример #17
0
def output_chart(chart, option):
    fig, ax = chart[:2]
    #ax.autoscale_view()

    xmin = date2num(datetime.fromtimestamp(option['view_start']))
    xmax = date2num(datetime.fromtimestamp(option['view_end']))
    ax.get_xaxis().set_view_interval(xmin, xmax, ignore=True)

    xmin, xmax = ax.get_xaxis().get_view_interval()
    ymin, ymax = ax.get_yaxis().get_view_interval()

    args = dict(color='black', linewidth=2)
    ax.add_artist(Line2D((xmin, xmax), (ymin, ymin), **args))
    ax.add_artist(Line2D((xmax, xmax), (ymin, ymax), **args))
    args = dict(color='black', linewidth=1)
    ax.add_artist(Line2D((xmin, xmax), (ymax, ymax), **args))
    ax.add_artist(Line2D((xmin, xmin), (ymin, ymax), **args))

    from matplotlib.dates import MinuteLocator

    locator = MinuteLocator(interval=int((option['view_end'] - option['view_start']) / 60 / 14))
    ax.get_xaxis().set_major_locator(locator)
    locator = MinuteLocator(interval=int((option['view_end'] - option['view_start']) / 60 / 14 / 2))
    ax.get_xaxis().set_minor_locator(locator)

    ax.get_xaxis().grid(which='both', color='#999999',
                        linestyle=':', lw=0.3)
    ax.get_yaxis().grid(which='both', color='#999999',
                        linestyle=':', lw=0.3)

    output = StringIO()
    plt.savefig(output, format='png', dpi=300)

    return output.getvalue()
Пример #18
0
def plotSEFD( infile, label ) :
    fin = open( infile, "r" ) 
    pyplot.clf()
    pyplot.ion()
    fig = pyplot.subplot(1,1,1)
    for line in fin :
      if not line.startswith('#') :
        a = line.split()
        color = 'black'
        if (a[2] == "SGRA" ) : color = 'red'
        if (a[2] == "M87" ) :  color = 'blue'
        t = datetime.datetime.strptime( a[3], "%H:%M:%S") 
        tt = mpdates.date2num(t)
        Cr = float(a[7]) 
        Cp = float(a[8]) 
        Cplow = float(a[9]) 
        Cphigh = float(a[10]) 
        fig.plot_date( tt, Cp, marker="o", color=color, linewidth=3 )
        fig.plot_date( tt, Cr, marker="s", fillstyle='full', alpha=0.5, color=color )
        fig.plot_date( [tt,tt], [Cplow,Cphigh], "-", linewidth=2, color=color )
    fin.close()
    fig.xaxis.set_major_locator(mpdates.HourLocator())
    fig.xaxis.set_major_formatter(mpdates.DateFormatter( "%H" ) )
    fig.set_yscale("log")
    tmin = mpdates.date2num( datetime.datetime.strptime( "00:00", "%H:%M") )
    tmax = mpdates.date2num( datetime.datetime.strptime( "19:00", "%H:%M") )
    fig.set_xlim( tmin-.02,tmax )
    fig.set_ylim( 1.e3,1.e6 )
    fig.text( .5, .94, label, verticalalignment="center", transform=fig.transAxes, \
      horizontalalignment="center", fontsize=18 )
    
    fig.grid()
    pyplot.xlabel( "UT (hrs)" )
    pyplot.ylabel( "SEFD (Jy)" )
    pyplot.show()
Пример #19
0
def runExample2():

    import matplotlib.dates as dates

    dbfile = 'C:/Projects/GOMGalveston/DATA/GalvestonObs.db'
    outvar = ['NetCDF_Filename','NetCDF_GroupID','StationName']
    tablename = 'observations'
    varname = 'waterlevel'
    condition = 'Variable_Name = "%s"' % varname
    
    data, query = queryNC(dbfile,outvar,tablename,condition)
    
    # Plot the results in one figure
    datemin = datetime(2011,6,1)
    datemax = datetime(2011,7,1)
    ylim = [27,35] # temp
    ylim = [0, 100] 
    fig = plt.figure(figsize=(8,12))
    plt.hold(True)
    k=0
    for dd in data:
        # convert the time for plotting
        t = dates.date2num(dd['time'])
        k+=1
        ax = plt.subplot(len(data),1,k)
        plt.plot(t,dd[varname],'b')
        plt.title('%s at %s'%(varname,query['StationName'][k-1]))
        # Format the x-ticks
        ax.set_xlim(dates.date2num(datemin), dates.date2num(datemax))
        ax.set_ylim(ylim[0],ylim[1])
        ax.grid(True)
        ax.xaxis.set_major_formatter(dates.DateFormatter('%d%b%Y'))
      
    fig.autofmt_xdate() 
    plt.show()
Пример #20
0
    def plot_group(self, group, idx, axis):
        # create x-coordinates for all log lines in this group
        x_start = date2num( [ logline.datetime for logline in self.groups[group] ] )
        x_end = date2num( [ logline.end_datetime for logline in self.groups[group] ] )

        color, marker = self.color_map(group)

        # duration plots require y coordinate and use plot_date
        y = [ getattr(logline, 'duration') for logline in self.groups[group] ]
        
        if self.logscale:
            axis.semilogy()

        # artist = axis.plot_date(x, y, color=color, markeredgecolor='k', marker=marker, alpha=0.7, \
        #     markersize=7, picker=5, label=group)[0]
        
        artists = []
        labels = set()

        for i, (xs, xe, ye) in enumerate(zip(x_start, x_end, y)):
            artist = axis.plot_date([xs, xe], [0, ye], '-', color=color, alpha=0.7, linewidth=2,
            markersize=7, picker=5, label=None if group in labels else group)[0]
            
            labels.add(group)

            # add meta-data for picking
            artist._mt_plot_type = self
            artist._mt_group = group 
            artist._mt_line_id = i
            artists.append(artist)

        return artists
    def _create_interpolators(self,dates):
        """
        Load the data from the RBSP spacecraft and create interpolator objects from it.
        """

        times,Lstar,MLT,MLAT,InvLat,density,segmentbounds=self._getdata(self.scname,dates)

        interpolators=np.zeros((len(segmentbounds)-1,),dtype=object)
        MLT_interpolators=np.zeros((len(segmentbounds)-1,),dtype=object)
        MLAT_interpolators=np.zeros((len(segmentbounds)-1,),dtype=object)
        InvLat_interpolators=np.zeros((len(segmentbounds)-1,),dtype=object)
        segmentlimits=np.zeros((len(segmentbounds)-1,2))

        for i in range(len(segmentbounds)-1):
            Lseg=Lstar[segmentbounds[i]:segmentbounds[i+1]]
            dseg=density[segmentbounds[i]:segmentbounds[i+1]]
            MLTseg=MLT[segmentbounds[i]:segmentbounds[i+1]]
            MLATseg=MLAT[segmentbounds[i]:segmentbounds[i+1]]
            InvLatseg=InvLat[segmentbounds[i]:segmentbounds[i+1]]
            tseg=times[segmentbounds[i]:segmentbounds[i+1]]

            inds=np.argsort(Lseg)

            interpolators[i]=UnivariateSpline(Lseg[inds],dseg[inds],**self.kwargs)
            if self.MLTDependence:
                MLT_interpolators[i]=UnivariateSpline(Lseg[inds],MLTseg[inds],**self.kwargs)
            if self.latitudeDependence:
                MLAT_interpolators[i]=UnivariateSpline(Lseg[inds],MLATseg[inds],**self.kwargs)
                InvLat_interpolators[i]=UnivariateSpline(Lseg[inds],InvLatseg[inds],**self.kwargs)
                
            segmentlimits[i,:]=date2num(tseg[0]),date2num(tseg[-1])

        return segmentlimits,interpolators,MLT_interpolators,MLAT_interpolators,InvLat_interpolators
Пример #22
0
    def __call__(self):
        # if no data have been set, this will tank with a ValueError
        _check_implicitly_registered()
        try:
            dmin, dmax = self.viewlim_to_dt()
        except ValueError:
            return []

        if dmin > dmax:
            dmax, dmin = dmin, dmax
        # We need to cap at the endpoints of valid datetime

        # TODO(wesm) unused?
        # delta = relativedelta(dmax, dmin)
        # try:
        #     start = dmin - delta
        # except ValueError:
        #     start = _from_ordinal(1.0)

        # try:
        #     stop = dmax + delta
        # except ValueError:
        #     # The magic number!
        #     stop = _from_ordinal(3652059.9999999)

        nmax, nmin = dates.date2num((dmax, dmin))

        num = (nmax - nmin) * 86400 * 1000
        max_millis_ticks = 6
        for interval in [1, 10, 50, 100, 200, 500]:
            if num <= interval * (max_millis_ticks - 1):
                self._interval = interval
                break
            else:
                # We went through the whole loop without breaking, default to 1
                self._interval = 1000.

        estimate = (nmax - nmin) / (self._get_unit() * self._get_interval())

        if estimate > self.MAXTICKS * 2:
            raise RuntimeError(('MillisecondLocator estimated to generate %d '
                                'ticks from %s to %s: exceeds Locator.MAXTICKS'
                                '* 2 (%d) ') %
                               (estimate, dmin, dmax, self.MAXTICKS * 2))

        freq = '%dL' % self._get_interval()
        tz = self.tz.tzname(None)
        st = _from_ordinal(dates.date2num(dmin))  # strip tz
        ed = _from_ordinal(dates.date2num(dmax))
        all_dates = date_range(start=st, end=ed, freq=freq, tz=tz).asobject

        try:
            if len(all_dates) > 0:
                locs = self.raise_if_exceeds(dates.date2num(all_dates))
                return locs
        except Exception:  # pragma: no cover
            pass

        lims = dates.date2num([dmin, dmax])
        return lims
Пример #23
0
 def demand_analysis(self,date=None,type='day',option=None):
     import calendar
     
     signal = 'Total_KW' # se estima la demanda PPP y PP en base a la estimacion del KW hecha a partir de AWH, BWH y CWH
     
     period = {'day':{'t1':date.replace(hour=0,minute=0,second=0,microsecond=0),\
                      't2':date.replace(hour=18,minute=00,second=00),\
                      't3':date.replace(hour=23,minute=00,second=00),\
                      't4':date.replace(hour=23,minute=59,second=59)}} 
     
     
     PPP     =   list(Measurements.objects.filter(Q(user= self.user),Q(sensor=Sensors.objects.get(pk=self.sensor_id)),\
                                 Q(datetimestamp__gte = period[type]['t1'], datetimestamp__lte =   period[type]['t2']) | Q(datetimestamp__gte = period[type]['t3'],datetimestamp__lte=period[type]['t4'])).extra(select=sql_extra_pairs[signal]['sql']).\
                                 order_by('datetimestamp').\
                                 values('datetimestamp',sql_extra_pairs[signal]['extra']))
     
     #valor maximo parcialmente presente en punta diario (consumo)
     PP    =   list(Measurements.objects.filter(Q(user= self.user),Q(sensor=Sensors.objects.get(pk=self.sensor_id)),\
                                 Q(datetimestamp__gte = period[type]['t2'], datetimestamp__lte =   period[type]['t3'])).extra(select=sql_extra_pairs[signal]['sql']).\
                                 order_by('datetimestamp').\
                                 values('datetimestamp',sql_extra_pairs[signal]['extra']))
     
     #exit if there are no data available
     if len(PP)==0 or len(PPP)==0:
         return {'PP':{'Value':0,'datetimestamp':date,'ave':0,'html':''},\
                 'PPP':{'Value':0,'datetimestamp':date,'ave':0,'html':''}}
     
     power_analisis =   {'PP':{'Value':0,'datetimestamp':date,'ave':0,'html':''},\
                      'PPP':{'Value':0,'datetimestamp':date,'ave':0,'html':''}}
     #busqueda del maximo PP
     for r in range(len(PP)-1):
         delta_r =   (date2num(PP[r+1]['datetimestamp'])-date2num(PP[r]['datetimestamp']))*24
         power_r =   float(PP[r+1][signal])/delta_r
         if power_r > power_analisis['PP']['Value']:
             power_analisis['PP']['Value'] = power_r
             power_analisis['PP']['datetimestamp'] = PP[r+1]['datetimestamp']
     
     power_r=0 #reset
     #busqueda del maximo PP
     for r in range(len(PPP)-1):
         delta_r =   (date2num(PPP[r+1]['datetimestamp'])-date2num(PPP[r]['datetimestamp']))*24
         power_r =   float(PPP[r+1][signal])/delta_r
         if power_r > power_analisis['PPP']['Value']:
             power_analisis['PPP']['Value'] = power_r
             power_analisis['PPP']['datetimestamp'] = PPP[r+1]['datetimestamp']
     
     #preparacion de datos, formatos, ganancias etc.
     power_analisis['PPP']['Value']  = power_analisis['PPP']['Value']*ganancias_dict['Total_KW']['gain']
     power_analisis['PP']['Value']   = power_analisis['PP']['Value']*ganancias_dict['Total_KW']['gain']
     
     power_analisis['PP']['html']    = pretty_print(power_analisis['PP']['Value'],label=['KW','MW'])    
     power_analisis['PPP']['html']   = pretty_print(power_analisis['PPP']['Value'],label=['KW','MW'])
     
     #se calcula la potencia promedio en base a la energia consumida en un periodo de tiempo y se divide por ese tiempo 
     
     power_analisis['PPP']['ave']    = self.calculo_consumo(date=date,type='day',option=['energy_by_time_range','PPP'])['Total']['Value']
     power_analisis['PP']['ave']     = self.calculo_consumo(date=date,type='day',option=['energy_by_time_range','PP'])['Total']['Value']
     
     #print power_analisis
     return power_analisis
Пример #24
0
def getcodar_ctl_id(model_option,url,datetime_wanted):
    if model_option=='1':
        dtime=open_url(url+'?time')
        dd=dtime['time']  
        #print "This option has data from "+str(num2date(dd[0]+date2num(datetime.datetime(2009, 1, 1, 0, 0))))+" to "+str(num2date(dd[-1]+date2num(datetime.datetime(2009, 1, 1, 0, 0))))           
        print 'This option has data from '+dd[0].strftime("%B %d, %Y")+' to '+dd[-1] .strftime("%B %d, %Y")
        id=datetime_wanted-date2num(datetime.datetime(2009, 1, 1, 0, 0))
        id=str(int(id))
    if model_option=='6':
        dtime=open_url(url+'?time')
        dd=dtime['time']
        ddd=[]
        #print 'This option has data from '+dd[0].strftime("%B %d, %Y")+' to '+dd[-1] .strftime("%B %d, %Y")
        id=datetime_wanted-date2num(datetime.datetime(2006, 1, 1, 0, 0))
        id=str(int(id))
    else:
        dtime=open_url(url+'?time')
        dd=dtime['time']
        ddd=[]
        for i in list(dtime['time']):
            i=round(i,7)
            ddd.append(i)
        
        #print "This option has data from "+str(num2date(dd[0]+date2num(datetime.datetime(2001, 1, 1, 0, 0))))+" to "+str(num2date(dd[-1]+date2num(datetime.datetime(2001, 1, 1, 0, 0)))) 
        #print 'This option has data from '+num2date(dd[0]).strftime("%B %d, %Y")+' to '+num2date(dd[-1]).strftime("%B %d, %Y")          
        id=ml.find(np.array(ddd)==round(datetime_wanted-date2num(datetime.datetime(2001, 1, 1, 0, 0)),7))
        for i in id:
          id=str(i) 
        #print 'codar id is  '+id
    return id    
Пример #25
0
def getemolt_sensor(mindtime1,maxdtime1,i_mindepth,i_maxdepth,site2,mindtime,maxdtime):
	  #According to the conditions to select data from "emolt_sensor"
	 
	  url2="http://gisweb.wh.whoi.edu:8080/dods/whoi/emolt_sensor?emolt_sensor.SITE,emolt_sensor.TIME_LOCAL,emolt_sensor.YRDAY0_LOCAL,emolt_sensor.TEMP,emolt_sensor.DEPTH_I&emolt_sensor.TIME_LOCAL>="+str(mindtime1)+"&emolt_sensor.TIME_LOCAL<="\
        +str(maxdtime1)+"&emolt_sensor.DEPTH_I>="+str(i_mindepth)+"&emolt_sensor.DEPTH_I<="+str(i_maxdepth)+site2
	  try:   
	           dataset1=open_url(url2)
	  except:
	           print 'Sorry, '+url2+' not available' 
	           sys.exit(0)
	  emolt_sensor=dataset1['emolt_sensor']
	  try:   
	          sites2=list(emolt_sensor['SITE'])
	  except:
	          print "'Sorry, According to your input, here are no value. please check it! ' "
	          sys.exit(0) 
	  #sites2=list(emolt_sensor['SITE'])
	  time=list(emolt_sensor['TIME_LOCAL'])
	  yrday0=list(emolt_sensor['YRDAY0_LOCAL'])
	  temp=list(emolt_sensor['TEMP'])
	  depth1=list(emolt_sensor['DEPTH_I'])
	
	
	  time1,temp1,yrday01,sites1,depth=[],[],[],[],[]
	  for m in range(len(time)):
	      #if mindtime<=dt.datetime.strptime(str(time[m]),'%Y-%m-%d')<=maxdtime:
	      if date2num(mindtime)<=yrday0[m]%1+date2num(dt.datetime.strptime(str(time[m]),'%Y-%m-%d'))<=date2num(maxdtime):
	      #if str(time[m])=='2012-01-01':
	        temp1.append(temp[m])
	        yrday01.append(yrday0[m]%1+date2num(dt.datetime.strptime(str(time[m]),'%Y-%m-%d')))
	        sites1.append(sites2[m])
	        time1.append(date2num(dt.datetime.strptime(str(time[m]),'%Y-%m-%d'))) 
	        depth.append(depth1[m])
	  #print len(temp1)     
	  return time1,yrday01,temp1,sites1,depth,
Пример #26
0
def main(sta1, sta2, filterid, components, mov_stack=1, show=True, outfile=None):
    db = connect()
    components_to_compute = get_components_to_compute(db)
    maxlag = float(get_config(db,'maxlag'))
    cc_sampling_rate = float(get_config(db,'cc_sampling_rate'))
    start, end, datelist = build_movstack_datelist(db)
    # mov_stack = get_config(db,"mov_stack")
 
   
    plt.figure(figsize=(16,16))
    sta1 = sta1.replace('.','_')
    sta2 = sta2.replace('.','_')
    if sta2 > sta1: # alphabetical order filtering!
        pair = "%s:%s"%(sta1,sta2)
        
        print("New Data for %s-%s-%i-%i"%(pair,components,filterid, mov_stack))
        format = "matrix"
        nstack, stack_total = get_results(db,sta1,sta2,filterid,components,datelist,mov_stack, format=format)
        # vmax = scoreatpercentile(np.abs(stack_total[np.isnan(stack_total)==False]) , 98)
        # for i in range(stack_total.shape[0]):
            # if not np.all( np.isnan(stack_total[i,:])):
                # print np.max(stack_total[i,:])
                # stack_total[i,:] /= np.max(stack_total[i,:])
        # stack_total /= np.max(stack_total, axis=0)
        xextent = (date2num(start), date2num(end),-maxlag,maxlag)
        ax = plt.subplot(111)
        plt.imshow(stack_total.T, extent=xextent, aspect="auto",interpolation='none',origin='lower',cmap='seismic',
                vmin=-1e-2,vmax=1e-2)
        plt.ylabel("Lag Time (s)")
        plt.axhline(0,lw=0.5,c='k')
        plt.grid()

        ax.xaxis.set_major_locator( YearLocator() )
        ax.xaxis.set_major_formatter(  DateFormatter('%Y-%m') )

        # ax.xaxis.set_minor_locator( MonthLocator(interval=2) )
        # ax.xaxis.set_minor_formatter(  DateFormatter('%Y-%m-%d') )
        
        lag = 120
        plt.ylim(-lag,lag)
        plt.title('%s : %s'%(sta1,sta2))
        name = '%i.%s_%s.png'%(filterid,sta1,sta2)

        #~ plt.savefig('interfero_publi.png',dpi=300)
        # plt.figure()
        # maxx = np.argmax(stack_total, axis=0)
        # plt.plot(maxx)
        
        if outfile:
            if outfile.startswith("?"):
                pair = pair.replace(':','-')
                outfile = outfile.replace('?', '%s-%s-f%i-m%i' % (pair,
                                                                  components,
                                                                  filterid,
                                                                  mov_stack))
            outfile = "interferogram " + outfile
            print("output to:", outfile)
            plt.savefig(outfile)
        if show:
            plt.show()
Пример #27
0
def PlotEntropyMapDate(dataset,L):

    f = open('aapl.csv','r')
    f.readline()

    data = []
    dataL = []
    counter = 0
    for lines in f:
        ls = lines.split(',')
        data.append((DT.datetime.strptime(ls[0], "%d-%b-%y"),float(ls[-1])))
        if counter%1000 == 0:
            dataL.append((DT.datetime.strptime(ls[0], "%d-%b-%y"),float(ls[-1])))
        counter = counter + 1

    x = [date2num(date) for (date, value) in data]
    y = [value for (date, value) in data]
    z = [EntropyFilter(Entropy([x,y], ii, L)) for ii in range(len(x))]

    xL = [date2num(date) for (date, value) in dataL]
    yL = [value for (date, value) in dataL]

    fig = plt.figure()

    graph = fig.add_subplot(111)
    graph.set_xticks(xL)
    graph.set_xticklabels([date.strftime("%d-%b-%y") for (date, value) in dataL])

    X = np.array(x)
    Y = np.array(y)
    Z = np.array(z)

    plt.scatter(X, Y, s = Z*10, c = Z)
    plt.show()
Пример #28
0
def calc_strong_motion():
    files1 = '/media/PBO/archive/20?[7890]/CX/PATCX/B[HL]Z.D/*.???'
    files2 = '/media/platte/Data/IPOC/raw_PATCX_2011_B-Z/*/*.???'
    acs = []
    vels = []
    for fname in glob(files1) + glob(files2):
        ms = read(fname)
        for tr in ms:
            if tr.stats.endtime - tr.stats.starttime < 1000:
                ms.remove(tr)
                continue
            tr.trim(tr.stats.starttime + 10, tr.stats.endtime - 10)
            tr.stats.filter = ''
            tr.detrend()
            tr.filter('highpass', freq=0.2)
        ms.merge(fill_value=0)
        if len(ms) == 0:
            continue
        tr = ms[0]
        t = tr.stats.starttime + (tr.stats.endtime - tr.stats.starttime) / 2
        maxi = np.max(np.abs(tr.data))
        if 'BH' in fname:
            vels.append((t, maxi))
        elif 'BL' in fname:
            acs.append((t, maxi))
        else:
            print 'wrong filename: ', fname
    dates_vel, vels = zip(*sorted(vels, key=itemgetter(0)))
    dates_ac, acs = zip(*sorted(acs, key=itemgetter(0)))
    np.savez('/home/richter/Results/IPOC/maxima_PATCX_5s.npz',
             dates_ac=date2num(dates_ac), dates_vel=date2num(dates_vel),
             vel=vels, ac=acs)
Пример #29
0
    def add_plot(self, sources):
        "Add a subplot to this widget displaying all of the signals in names"
        
        rows = len(self.plots) + 1
        for i, plot in enumerate(self.plots):
            plot.change_geometry(rows, 1, i+1)
            plot.label_outer()
        
        new_plot = LiveSubplot(self.find_source, self, rows, 1, rows)
        td = datetime.timedelta(seconds=self.timescale)
        
        now = datetime.datetime.utcnow()
        new_plot.set_xbound(mdates.date2num(now - td),
                            mdates.date2num(now))
        if len(sources) == 1:
            new_plot.set_title(sources[0]["name"])

        for descr in sources:
            new_plot.add_signal(descr["identifier"],
                                color=descr["color"],
                                style=descr["style"])

        self.figure.add_subplot(new_plot)
        self.plots.append(new_plot)

        return new_plot
Пример #30
0
 def _format_plot(self):
     """Formats the plot, i.e. scales axes, sets ticks, etc."""
     # enable grid
     self.ax_left.grid(True)
     # format x-axis
     daterange = self.end_date - self.start_date
     majorlocator, majorformatter, minorlocator = _get_locators(daterange)
     self.ax_left.set_xlim(
             dates.date2num(self.start_date), dates.date2num(self.end_date))
     self.ax_left.xaxis.set_major_locator(majorlocator)
     self.ax_left.xaxis.set_major_formatter(majorformatter)
     self.ax_left.xaxis.set_minor_locator(minorlocator)
     # format y-axis
     y_min, y_max = self._get_ylimits(yaxis='left')
     if y_min is not None:
         self.ax_left.set_ylim(y_min, y_max)
     y_min, y_max = self._get_ylimits(yaxis='right')
     if y_min is not None:
         self.ax_right.set_visible(True)
         self.ax_right.set_ylim(y_min, y_max)
     else:
         self.ax_right.set_visible(False)
     # set label on y-axis
     self.ax_left.set_ylabel(self.ylabels[self.left_datatype])
     self.ax_right.set_ylabel(self.ylabels[self.right_datatype])
Пример #31
0
    def create_header(self, so, psd=False):

        #matplotlib options for graph
        font = {'family': 'DejaVu Sans', 'size': 14}
        matplotlib.rc('font', **font)
        plt.rcParams['figure.figsize'] = (16, 10)
        plt.rcParams['figure.facecolor'] = 'white'

        #make the figure
        self.figure = plt.figure(figsize=(16, 10))

        #Get the time nums for the statistics
        first_date = uc.convert_ms_to_date(so.stat_dictionary['time'][0],
                                           pytz.UTC)
        last_date = uc.convert_ms_to_date(so.stat_dictionary['time'][-1],
                                          pytz.UTC)
        new_dates = uc.adjust_from_gmt([first_date,last_date], \
                                         so.timezone,so.daylight_savings)

        first_date = mdates.date2num(new_dates[0])
        last_date = mdates.date2num(new_dates[1])

        time = so.stat_dictionary['time']
        self.time_nums = np.linspace(first_date, last_date, len(time))

        #Get the time nums for the wave water level
        first_date = uc.convert_ms_to_date(so.sea_time[0], pytz.UTC)
        last_date = uc.convert_ms_to_date(so.sea_time[-1], pytz.UTC)
        new_dates = uc.adjust_from_gmt([first_date,last_date], \
                                         so.timezone,so.daylight_savings)

        first_date = mdates.date2num(new_dates[0])
        last_date = mdates.date2num(new_dates[1])

        time = so.sea_time
        self.time_nums2 = np.linspace(first_date, last_date, len(time))

        #Read images
        logo = image.imread('usgs.png', None)

        #Create grids for section formatting

        if psd == False:
            self.grid_spec = gridspec.GridSpec(2,
                                               2,
                                               width_ratios=[1, 2],
                                               height_ratios=[1, 4])
        else:
            self.grid_spec = gridspec.GridSpec(2,
                                               2,
                                               width_ratios=[1, 2],
                                               height_ratios=[1, 7])
        #---------------------------------------Logo Section
        ax2 = self.figure.add_subplot(self.grid_spec[0, 0])
        ax2.set_axis_off()

        ax2.axes.get_yaxis().set_visible(False)
        ax2.axes.get_xaxis().set_visible(False)
        pos1 = ax2.get_position()  # get the original position

        if psd == False:
            pos2 = [pos1.x0, pos1.y0 + .07, pos1.width, pos1.height]
            ax2.set_position(pos2)  # set a new position
        else:
            pos2 = [
                pos1.x0 - .062, pos1.y0 + .01, pos1.width + .1,
                pos1.height + .05
            ]
            ax2.set_position(pos2)  # set a new position

        #display logo
        ax2.imshow(logo)
Пример #32
0
def IDL_time_to_num(time_in):  
 #convert IDL time to matplotlib datetime
 time_num=np.zeros(np.size(time_in))
 for ii in np.arange(0,np.size(time_in)):
   time_num[ii]=mdates.date2num(sunpy.time.parse_time(time_in[ii]))   
 return time_num 
Пример #33
0
mo_pdyn=i.icmecat['MO_PDYN']
mo_pdyn_std=i.icmecat['MO_PDYN_STD']


#get indices of events by different spacecraft
ivexind=np.where(isc == 'VEX')
istaind=np.where(isc == 'STEREO-A')
istbind=np.where(isc == 'STEREO-B')
iwinind=np.where(isc == 'Wind')
imesind=np.where(isc == 'MESSENGER')
iulyind=np.where(isc == 'ULYSSES')
imavind=np.where(isc == 'MAVEN')


#take MESSENGER only at Mercury, only events after orbit insertion
imercind=np.where(np.logical_and(isc =='MESSENGER',icme_start_time_num > mdates.date2num(sunpy.time.parse_time('2011-03-18'))))

#limits of solar minimum, rising phase and solar maximum

minstart=mdates.date2num(sunpy.time.parse_time('2007-01-01'))
minend=mdates.date2num(sunpy.time.parse_time('2009-12-31'))

risestart=mdates.date2num(sunpy.time.parse_time('2010-01-01'))
riseend=mdates.date2num(sunpy.time.parse_time('2011-06-30'))

maxstart=mdates.date2num(sunpy.time.parse_time('2011-07-01'))
maxend=mdates.date2num(sunpy.time.parse_time('2014-12-31'))


#extract events by limits of solar min, rising, max, too few events for MAVEN and Ulysses
Пример #34
0
    107,
    'Mar 2019',
    42,
    108,
    'Apr 2019',
    42,
    107,
]

# Strip out the dates from membership_data
date_strings = membership_data[0::3]

# Convert date strings into numbers
date_nums = []
for d in date_strings:
    date_nums.append(date2num(datetime.strptime(d, '%b %Y')))

# Strip out the number of libmesh-devel subscribers from membership_data
devel_count = membership_data[1::3]

# Strip out the number of libmesh-users subscribers from membership_data
users_count = membership_data[2::3]

# Get a reference to the figure
fig = plt.figure()

# 111 is equivalent to Matlab's subplot(1,1,1) command
ax = fig.add_subplot(111)

# The colors used come from sns.color_palette("muted").as_hex() They
# are the "same basic order of hues as the default matplotlib color
Пример #35
0
  def time_series(self,varname,x,y,times=None,depth=None,**opts):
    coords=opts.get('coords',self._default_coords('time_series')).split(',')

    if times is None: times=range(0,self.time.size)

    # depth or s_level: check is is float or if is negative!
    isDepth=False
    if not depth is None:
       if calc.isiterable(depth): depth=np.asarray(depth)
       if calc.isarray(depth):
         isDepth=np.any(depth<0) or depth.kind!='i' 
       else: isDepth=depth<0 or np.asarray(depth).dtype.kind!='i'

    out=Data()
    if not depth is None and not isDepth:
      out.msg=self.check_slice(varname,t=np.max(times),k=depth) 
    else:
      out.msg=self.check_slice(varname,t=np.max(times)) 

    if out.msg: return out

    # find nearest point:
    lon,lat,hr,mr=self.grid.vars(ruvp=self.var_at(varname))
    dist=(lon-x)**2+(lat-y)**2
    i,j=np.where(dist==dist.min())
    i,j=i[0],j[0]

    if not depth is None and not isDepth: arg={'s_SEARCH':depth}
    else: arg={}
    v=self.use(varname,xiSEARCH=j,etaSEARCH=i,SEARCHtime=times,**arg).T

    # calculate depths:
    if self.hasz(varname):
      h=self.grid.h[i,j]
      zeta=self.use('zeta',xiSEARCH=j,etaSEARCH=i,SEARCHtime=times)
      h=h+0*zeta
####      z=rt.s_levels(h,zeta,self.s_params,rw=varname)
      z=rt.s_levels(h,zeta,self.s_params,rw=self.var_at(varname)[1])
      z=np.squeeze(z)

    # depth slice:
    if isDepth and self.hasz(varname):
      if v.ndim==2:
        # could use calc.griddata, but better use slicez cos data at
        # different times may be independent!
        if 0:
          from matplotlib.dates import date2num
          t=np.tile(date2num(self.time[times]),(v.shape[0],1))
          v=calc.griddata(t,z,v,t[0],depth+np.zeros(t[0].shape),
            extrap=opts.get('extrap',False),norm_xy=opts.get('norm_xy',False))
            # norm_xy True may be needed!
            # extrap also may be needed cos the 1st and last value may be masked!

        else:
          nt=len(times)
          land_mask=np.ones((nt,1),dtype=v.dtype) # needed for slicez... not used here!        

          v,vm=rt.slicez(v[...,np.newaxis],land_mask,
               self.grid.h[i,j]*np.ones((nt,1),dtype=v.dtype), # bottom depth
               zeta[:,np.newaxis],self.s_params,depth,spline=opts.get('spline',True))

          v=np.ma.masked_where(vm,v)
          v=v[...,0]

      else: # one time only
        v=np.interp(depth,z,v,left=np.nan,right=np.nan)
        v=np.ma.masked_where(np.isnan(v),v) 


    out.v=v
    out.info['v']['name']=varname
    out.info['v']['slice']='time series'
    try: out.info['v']['units']=netcdf.vatt(self.nc,varname,'units')
    except: pass
     
    # coords
    if 't' in coords and self.hast(varname):
      if v.ndim==2:
        out.t=np.tile(self.time[times],(v.shape[0],1))
        from matplotlib.dates import date2num
        out.tnum=np.tile(date2num(self.time[times]),(v.shape[0],1))
      else: out.t=self.time[times]
      out.info['t']['name']='Time'
      out.info['tnum']=dict(name='Time',units=self.var_as['time']['units'])

    if 'z' in coords and self.hasz(varname):
      if not depth is None:
        if not isDepth: out.z=z[depth,...]
        else: out.z=depth+0*v
      else: out.z=z
      out.info['z']=dict(name='Depth',units='m')

    if 'x' in coords:
      out.x=lon[i,j]
      if self.grid.is_spherical:
         out.info['x']=dict(name='Longitude',units=r'$\^o$E')
      else:
        out.x=x/1000.
        out.info['x']=dict(name='X-position',units='km')

    if 'y' in coords:
      out.y=lat[i,j]
      if self.grid.is_spherical:
        out.info['y']=dict(name='Latitude',units=r'$\^o$N')
      else:
        out.y=y/1000.
        out.info['y']=dict(name='Y-position',units='km')


    out.coordsReq=','.join(sorted(coords))
    return out
Пример #36
0
    def do_plot(self, wallet, history):
        balance_Val = []
        fee_val = []
        value_val = []
        datenums = []
        unknown_trans = 0
        pending_trans = 0
        counter_trans = 0
        balance = 0
        for item in history:
            tx_hash, confirmations, value, timestamp, balance = item
            if confirmations:
                if timestamp is not None:
                    try:
                        datenums.append(
                            md.date2num(
                                datetime.datetime.fromtimestamp(timestamp)))
                        balance_Val.append(1000. * balance / COIN)
                    except [RuntimeError, TypeError, NameError] as reason:
                        unknown_trans += 1
                        pass
                else:
                    unknown_trans += 1
            else:
                pending_trans += 1

            value_val.append(1000. * value / COIN)
            if tx_hash:
                label, is_default_label = wallet.get_label(tx_hash)
                label = label.encode('utf-8')
            else:
                label = ""

        f, axarr = plt.subplots(2, sharex=True)

        plt.subplots_adjust(bottom=0.2)
        plt.xticks(rotation=25)
        ax = plt.gca()
        x = 19
        test11 = "Unknown transactions =  " + str(
            unknown_trans) + " Pending transactions =  " + str(
                pending_trans) + " ."
        box1 = TextArea(" Test : Number of pending transactions",
                        textprops=dict(color="k"))
        box1.set_text(test11)

        box = HPacker(children=[box1], align="center", pad=0.1, sep=15)

        anchored_box = AnchoredOffsetbox(
            loc=3,
            child=box,
            pad=0.5,
            frameon=True,
            bbox_to_anchor=(0.5, 1.02),
            bbox_transform=ax.transAxes,
            borderpad=0.5,
        )

        ax.add_artist(anchored_box)

        plt.ylabel('mBOLI')
        plt.xlabel('Dates')
        xfmt = md.DateFormatter('%Y-%m-%d')
        ax.xaxis.set_major_formatter(xfmt)

        axarr[0].plot(datenums,
                      balance_Val,
                      marker='o',
                      linestyle='-',
                      color='blue',
                      label='Balance')
        axarr[0].legend(loc='upper left')
        axarr[0].set_title('History Transactions')

        xfmt = md.DateFormatter('%Y-%m-%d')
        ax.xaxis.set_major_formatter(xfmt)
        axarr[1].plot(datenums,
                      value_val,
                      marker='o',
                      linestyle='-',
                      color='green',
                      label='Value')

        axarr[1].legend(loc='upper left')
        #   plt.annotate('unknown transaction = %d \n pending transactions = %d' %(unknown_trans,pending_trans),xy=(0.7,0.05),xycoords='axes fraction',size=12)
        plt.show()
Пример #37
0
        }
        out_st = Stream([Trace(data=np.array(data), header=stats)])
        out_st.write(year_rsam_file, format='MSEED', reclen=256)

# Make RSAM plot folder if required

if not os.path.exists('./output/'):
    os.makedirs('./output')

# Plot RSAM data

for stream in streams:

    # Set plot dates

    yd1 = date2num(date - datetime.timedelta(days=num_plot_days)) + 1
    yd2 = date2num(date)
    dates = num2date(np.arange(yd1, yd2, 1))

    # Gather data for plotting

    frequency_ranges = args.filter_ranges.split('],[')
    frequency_banded_traces = []
    for frequency_range in frequency_ranges:
        frequency_bounds = frequency_range.replace('[',
                                                   '').replace(']',
                                                               '').split(',')

        print('Plotting 10-minute mean RSAM values for ' + stream +
              ' between dates ' +
              str(date - datetime.timedelta(days=num_plot_days))[:10] +
Пример #38
0
def get_laohu_analysis(n, url, li_code): 
    fig, axes = plt.subplots(nrows=10, ncols=10, figsize=(30,30))
    li=[]
    nu_nu=0
    jo=pd.DataFrame()
    quotes=pd.DataFrame()   
    for code_nm in li_code:
        print('--------------------------------------'+str(nu_nu+(n*100))+'----------------------------------------------')
        con = requests.get(url.format(str(code_nm)), headers=header).json()
        time.sleep(0.1) 
        li_data=con.get('items')
        if li_data is not None:
            jo=pd.DataFrame(li_data)
            quotes=jo.copy()
            
            quotes=quotes.sort_values(by="time", ascending=False)[:15]
            quotes=quotes.sort_values(by="time", ascending=True)

            quotes['time']=quotes['time'].apply(todate)
            quotes['time']=pd.to_datetime(quotes['time'], format="%Y-%m-%d")

            x = jo['time'].values
            y = jo['close'].values
            vol = jo['volume'].values
            vol_li = jo['volume'].tolist()
            vol_min=min(vol_li)
            vol_max=max(vol_li)
            vol_up=(vol_max-vol_min)*0.3+vol_max
            z1 = np.polyfit(x, y, 4)#用3次多项式拟合
            p1 = np.poly1d(z1)
            # print(p1) #在屏幕上打印拟合多项式
            yvals=p1(x)#也可以使用yvals=np.polyval(z1,x)
            der=p1.deriv(m=2)
            dder=der(x)
            dder_list = dder.tolist()
            maxindex=dder_list.index(max(dder_list))
            # print(maxindex)
            time_max=jo['time'][maxindex]
            close_max=jo['close'][maxindex]
            p1_max=p1(time_max)



            # print(jo)
            ax=axes[nu_nu//10, nu_nu%10]
            count=quotes.shape[0]
            year=int(count/48)
            ax.set_title(str(code_nm)+'('+str(year)+')',fontsize=18,fontweight='bold')    
            # plot1=ax.plot(x, y, marker=r'$\clubsuit$', color='goldenrod',markersize=15,label='original values')
            # plot1=ax.plot(x, y, 'o', color='goldenrod',markersize=10,label='original values')   
            
            # data_list=[]
            # for row in quotes.itertuples():
            #     date_time = datetime.datetime.strptime(getattr(row,'time'),'%Y-%m-%d')
            #     t = date2num(date_time)
            #     open_tmp = getattr(row,'open')
            #     high_tmp = getattr(row,'high')
            #     low_tmp  = getattr(row,'low')
            #     close_tmp = getattr(row,'close')
            #     datas = (t,open_tmp,high_tmp,low_tmp,close_tmp)
            #     data_list.append(datas)
            
            candlestick_ohlc(ax, zip(mdates.date2num(quotes['time'].dt.to_pydatetime()),
                         quotes['open'], quotes['high'],
                         quotes['low'], quotes['close']),
                 width=0.6,colordown='#53c156', colorup='#ff1717')
            

            # if len(quotes["close"].tolist()) >200:
            #     ma150 = moving_average(quotes["close"], 150, type='simple')
            #     ma200 = moving_average(quotes["close"], 200, type='simple')

            #     linema150, = ax.plot(quotes['time'], ma150, color='blue', lw=2, label='MA (150)')
            #     linema200, = ax.plot(quotes['time'], ma200, color='red', lw=2, label='MA (200)')


            # mpf.candlestick_ohlc(ax,data_list,width=1.5,colorup='r',colordown='green')
        
            ax.xaxis.set_major_locator(ticker.NullLocator())
            ax.set_ylabel(' ', fontsize=0.01)
            ax.set_xlabel(' ', fontsize=0.01)
            ax.spines['top'].set_linewidth(2)
            ax.spines['bottom'].set_linewidth(2)
            ax.spines['left'].set_linewidth(2)
            ax.spines['right'].set_linewidth(2)
            for label in ax.get_xticklabels() + ax.get_yticklabels():
                label.set_fontsize(14)
            
 
            ax2t = ax.twinx()
            volume = (quotes.close * quotes.volume) / 1e6  # dollar volume in millions
            vmax = volume.max()
            fillcolor = 'darkgoldenrod'
            poly = ax2t.fill_between(quotes.time.values, volume, 0, label='Volume',
                         facecolor=fillcolor, edgecolor=fillcolor)
            
            ax2t.set_ylim(0, 20 * vmax)
            ax2t.set_yticks([])
            ax2t.set_xticks([])

            del jo, quotes
            gc.collect()

            # mondays = WeekdayLocator(MONDAY)
            # ax.xaxis.set_major_locator(mondays)
            # daysFmt = DateFormatter("%m%d")
            # ax.xaxis.set_major_formatter(daysFmt)

            # ax2t.autoscale_view()
            # ax2 = ax.twinx()
            # plot3=ax2.plot(x, vol, zorder=0, c="g",linewidth=2,alpha=0.7)
            # ax2.set_zorder(0)
            # # ax2.set_ylabel('volume')
            # ax2.set_ylim(vol_min,vol_up) 
            # ax2.yaxis.set_major_locator(plt.NullLocator()) 
        nu_nu=nu_nu+1    
    fig.tight_layout(rect=[0.02,0.02,0.98,0.98], pad=0.2, h_pad=0.2, w_pad=0.2)
    fig.subplots_adjust(wspace =0.2, hspace =0.2)
    plt.savefig('D:/Git/us_stock/technical_analysis/Main/up/4up1down1up_no_limit/up_data/'+date+"_fig_up_price_"+str(n)+".png")
import io_helper as ioh

# define the location of the price data file
filename_bitmex_data = "data/bitmex_data.msgpack.zlib"

# load the price data
with open(filename_bitmex_data, "rb") as f:
    temp = msgpack.unpackb(zlib.decompress(f.read()))
    price_symbol = temp[0]['symbol']
    t_price_data = np.array([el["t_epoch"] for el in temp], dtype=np.float64)
    #price_data = np.array([el["open"] for el in temp], dtype=np.float64)
    price_data = np.array([el["close"] for el in temp], dtype=np.float64)

# initialise some labels for the plot
datenum_price_data = [
    md.date2num(datetime.datetime.fromtimestamp(el)) for el in t_price_data
]

datenum_price_data = datenum_price_data[::24]
price_data = price_data[::24]

# define the location of the input file
filename_article_results = "results/article_results.json"

# load the article data
with open(filename_article_results, "rb") as f:
    article_results = json.load(f)
    article_symbol = article_results['symbol']

# define the location of the input file
filename_funding_results = "results/funding_results.json"
Пример #40
0
    def display(self, symbol, orders, klines):
        """
        gs = gridspec.GridSpec(8, 1)
        gs.update(left=0.04, bottom=0.04, right=1, top=1, wspace=0, hspace=0)
        axes = [
            plt.subplot(gs[0:-2, :]),
            #plt.subplot(gs[-4:-2, :]),
            plt.subplot(gs[-2:-1, :]),
            plt.subplot(gs[-1, :])
        ]
        """
        fig, axes = plt.subplots(5, 1, sharex=True)
        fig.subplots_adjust(left=0.04,
                            bottom=0.04,
                            right=1,
                            top=1,
                            wspace=0,
                            hspace=0)

        trade_times = [order["trade_time"] for order in orders]

        quotes = []
        for k in klines:
            d = datetime.fromtimestamp(k[0] / 1000)
            quote = (dts.date2num(d), float(k[1]), float(k[4]), float(k[2]),
                     float(k[3]))
            quotes.append(quote)

        mpf.candlestick_ochl(axes[0],
                             quotes,
                             width=0.2,
                             colorup='g',
                             colordown='r')
        axes[0].set_ylabel('price')
        axes[0].grid(True)
        axes[0].autoscale_view()
        axes[0].xaxis_date()
        axes[0].plot(trade_times, [(order["deal_value"] / order["deal_amount"])
                                   for order in orders], "o--")

        klines_df = pd.DataFrame(klines, columns=self.kline_column_names)
        open_times = [
            datetime.fromtimestamp((open_time / 1000))
            for open_time in klines_df["open_time"]
        ]
        klines_df["close"] = pd.to_numeric(klines_df["close"])
        base_close = klines_df["close"].values[0]

        klines_df["ATR"] = talib.ATR(klines_df["high"],
                                     klines_df["low"],
                                     klines_df["close"],
                                     timeperiod=14)
        klines_df["NATR"] = talib.NATR(klines_df["high"],
                                       klines_df["low"],
                                       klines_df["close"],
                                       timeperiod=14)
        klines_df["TRANGE"] = talib.TRANGE(klines_df["high"], klines_df["low"],
                                           klines_df["close"])

        # axes[0].plot(open_times, klines_df["ATR"]*10, "y:", label="ATR")

        axes[1].set_ylabel('volatility')
        axes[1].grid(True)
        axes[1].plot(open_times, klines_df["ATR"], "y:", label="ATR")
        axes[1].plot(open_times, klines_df["NATR"], "k--", label="NATR")
        axes[1].plot(open_times, klines_df["TRANGE"], "c--", label="TRANGE")

        ks, ds, js = ic.pd_kdj(klines_df)
        axes[2].set_ylabel('kdj')
        axes[2].grid(True)
        axes[2].plot(open_times, ks, "b", label="k")
        axes[2].plot(open_times, ds, "y", label="d")
        axes[2].plot(open_times, js, "m", label="j")

        axes[-2].set_ylabel('total profit rate')
        axes[-2].grid(True)
        axes[-2].plot(
            trade_times,
            [round(100 * order["total_profit_rate"], 2)
             for order in orders], "go--")
        axes[-2].plot(open_times, [
            round(100 * ((close / base_close) - 1), 2)
            for close in klines_df["close"]
        ], "r--")

        axes[-1].set_ylabel('rate')
        axes[-1].grid(True)
        #axes[-1].set_label(["position rate", "profit rate"])
        axes[-1].plot(trade_times,
                      [round(100 * order["pst_rate"], 2) for order in orders],
                      "k-",
                      drawstyle="steps-post",
                      label="position")
        axes[-1].plot(trade_times, [
            round(100 * order["floating_profit_rate"], 2) for order in orders
        ],
                      "g--",
                      drawstyle="steps",
                      label="profit")
        """
        trade_times = []
        pst_rates = []
        for i, order in enumerate(orders):
            #补充
            if i > 0 and orders[i-1]["pst_rate"] > 0:
                tmp_trade_date = orders[i-1]["trade_time"].date() + timedelta(days=1)
                while tmp_trade_date < order["trade_time"].date():
                    trade_times.append(tmp_trade_date)
                    pst_rates.append(orders[i-1]["pst_rate"])
                    print("add %s, %s" % (tmp_trade_date, orders[i-1]["pst_rate"]))
                    tmp_trade_date += timedelta(days=1)

            # 添加
            trade_times.append(order["trade_time"])
            pst_rates.append(order["pst_rate"])
            print("%s, %s" % (order["trade_time"], order["pst_rate"]))
        plt.bar(trade_times, pst_rates, width= 0.3) # 
        """

        plt.show()
Пример #41
0
from matplotlib.dates import date2num
# from base_def import BaseEnum

# Set contants for unpacking .raw files
BLOCK_SIZE = 1024 * 4  # Block size read in from binary file to search for token
LENGTH_SIZE = 4
DATAGRAM_HEADER_SIZE = 12
CONFIG_HEADER_SIZE = 516
CONFIG_TRANSDUCER_SIZE = 320

# set global regex expressions to find all sample, annotation and NMEA sentences
SAMPLE_REGEX = b'RAW\d{1}'
SAMPLE_MATCHER = re.compile(SAMPLE_REGEX, re.DOTALL)

# Reference time "seconds since 1900-01-01 00:00:00"
REF_TIME = date2num(dt(1900, 1, 1, 0, 0, 0))

# ---------- NEED A GENERIC FILENAME PARSER -------------
# Common EK60 *.raw filename format
# EK60_RAW_NAME_REGEX = r'(?P<Refdes>\S*)_*OOI-D(?P<Date>\d{8})-T(?P<Time>\d{6})\.raw'
# EK60_RAW_NAME_MATCHER = re.compile(EK60_RAW_NAME_REGEX)

# # Regex to extract the timestamp from the *.raw filename (path/to/OOI-DYYYYmmdd-THHMMSS.raw)
# FILE_NAME_REGEX = r'(?P<Refdes>\S*)_*OOI-D(?P<Date>\d{8})-T(?P<Time>\d{6})\.raw'
# FILE_NAME_MATCHER = re.compile(FILE_NAME_REGEX)

WINDOWS_EPOCH = dt(1601, 1, 1)
NTP_EPOCH = dt(1900, 1, 1)
NTP_WINDOWS_DELTA = (NTP_EPOCH - WINDOWS_EPOCH).total_seconds()

# Numpy data type object for unpacking the Sample datagram including the header from binary *.raw
Пример #42
0
def animate(i):
    global refreshRate
    global DatCounter

    def rsiIndicator(priceData, location="top"):

        try:
            if location == "top":
                values = {
                    'key': 1,
                    "prices": priceData,
                    "periods": topIndicator[1]
                }
            if location == "bottom":
                values = {
                    'key': 1,
                    "prices": priceData,
                    "periods": bottomIndicator[1]
                }

            url = "http://seaofbtc.com/api/indicator/rsi"

            data = urllib.parse.urlencode(values)
            data = data.encode("utf-8")

            req = urllib.request.Request(url, data)
            resp = urllib.request.urlopen(req)

            respData = resp.read()

            newData = str(respData).replace("b", "").replace("[", "").replace(
                "]", "").replace("'", "")
            priceList = newData.split(', ')

            rsiData = [float(i) for i in priceList]

            if location == "top":
                a0.plot_date(OHLC['MPLDates'],
                             rsiData,
                             lightColor,
                             label="RSI")
                #datLabel = "RSI("+str(topIndicator[1])+")"
                #a0.set_ylabel(datLabel)

            if location == "bottom":
                a3.plot_date(OHLC['MPLDates'],
                             rsiData,
                             lightColor,
                             label="RSI")
                #datLabel = "RSI("+str(topIndicator[1])+")"
                #a3.set_ylabel(datLabel)
        except Exception as e:
            print("failed in rsi", str(e))

    if chartLoad:
        if paneCount == 1:
            if DataPace == "tick":
                try:
                    if exchange == "BTC-e":
                        a = plt.subplot2grid((6, 4), (0, 0),
                                             rowspan=5,
                                             colspan=4)
                        a2 = plt.subplot2grid((6, 4), (5, 0),
                                              rowspan=1,
                                              colspan=4,
                                              sharex=a)

                        dataLink = 'https://btc-e.com/api/3/trades/btc_usd?limit=2000'
                        data = urllib.request.urlopen(dataLink)
                        data = data.readall().decode("utf-8")
                        data = json.loads(data)

                        data = data["btc_usd"]
                        data = pd.DataFrame(data)

                        data["datestamp"] = np.array(
                            data['timestamp']).astype("datetime64[s]")
                        allDates = data["datestamp"].tolist()

                        buys = data[(data['type'] == "bid")]
                        #buys["datestamp"] = np.array(buys["timestamp"]).astype("datetime64[s]")
                        buyDates = (buys["datestamp"]).tolist()

                        sells = data[(data['type'] == "ask")]
                        #sells["datestamp"] = np.array(sells["timestamp"]).astype("datetime64[s]")
                        sellDates = (sells["datestamp"]).tolist()

                        volume = data["amount"]

                        a.clear()

                        a.plot_date(buyDates,
                                    buys["price"],
                                    lightColor,
                                    label="buys")
                        a.plot_date(sellDates,
                                    sells["price"],
                                    darkColor,
                                    label="sells")

                        a2.fill_between(allDates,
                                        0,
                                        volume,
                                        facecolor=darkColor)

                        a.xaxis.set_major_locator(mticker.MaxNLocator(5))
                        a.xaxis.set_major_formatter(
                            mdates.DateFormatter("%Y-%m-%d %H:%M:%S"))
                        plt.setp(a.get_xticklabels(), visible=False)

                        a.legend(bbox_to_anchor=(0, 1.02, 1, .102),
                                 loc=3,
                                 ncol=2,
                                 borderaxespad=0)

                        title = "BTC-e BTCUSD Prices\nLast Price: " + str(
                            data["price"][1999])
                        a.set_title(title)
                        priceData = data['price'].apply(float).tolist()

                    if exchange == "Bitstamp":
                        a = plt.subplot2grid((6, 4), (0, 0),
                                             rowspan=5,
                                             colspan=4)
                        a2 = plt.subplot2grid((6, 4), (5, 0),
                                              rowspan=1,
                                              colspan=4,
                                              sharex=a)

                        dataLink = 'https://www.bitstamp.net/api/transactions/'
                        data = urllib.request.urlopen(dataLink)
                        data = data.readall().decode("utf-8")
                        data = json.loads(data)

                        data = pd.DataFrame(data)

                        data["datestamp"] = np.array(
                            data['date'].apply(int)).astype("datetime64[s]")
                        dateStamps = data["datestamp"].tolist()
                        #allDates = data["datestamp"].tolist()

                        ##                        buys = data[(data['type']=="bid")]
                        ##                        #buys["datestamp"] = np.array(buys["timestamp"]).astype("datetime64[s]")
                        ##                        buyDates = (buys["datestamp"]).tolist()
                        ##
                        ##
                        ##                        sells = data[(data['type']=="ask")]
                        ##                        #sells["datestamp"] = np.array(sells["timestamp"]).astype("datetime64[s]")
                        ##                        sellDates = (sells["datestamp"]).tolist()

                        volume = data["amount"].apply(float).tolist()

                        a.clear()

                        a.plot_date(dateStamps,
                                    data["price"],
                                    lightColor,
                                    label="buys")

                        a2.fill_between(dateStamps,
                                        0,
                                        volume,
                                        facecolor=darkColor)

                        a.xaxis.set_major_locator(mticker.MaxNLocator(5))
                        a.xaxis.set_major_formatter(
                            mdates.DateFormatter("%Y-%m-%d %H:%M:%S"))
                        plt.setp(a.get_xticklabels(), visible=False)

                        a.legend(bbox_to_anchor=(0, 1.02, 1, .102),
                                 loc=3,
                                 ncol=2,
                                 borderaxespad=0)

                        title = "Bitstamp BTCUSD Prices\nLast Price: " + str(
                            data["price"][0])
                        a.set_title(title)
                        priceData = data['price'].apply(float).tolist()

                    if exchange == "Bitfinex":
                        a = plt.subplot2grid((6, 4), (0, 0),
                                             rowspan=5,
                                             colspan=4)
                        a2 = plt.subplot2grid((6, 4), (5, 0),
                                              rowspan=1,
                                              colspan=4,
                                              sharex=a)

                        dataLink = 'https://api.bitfinex.com/v1/trades/btcusd?limit=2000'
                        data = urllib.request.urlopen(dataLink)
                        data = data.readall().decode("utf-8")
                        data = json.loads(data)

                        data = pd.DataFrame(data)

                        data["datestamp"] = np.array(
                            data['timestamp']).astype("datetime64[s]")
                        allDates = data["datestamp"].tolist()

                        buys = data[(data['type'] == "buy")]
                        #buys["datestamp"] = np.array(buys["timestamp"]).astype("datetime64[s]")
                        buyDates = (buys["datestamp"]).tolist()

                        sells = data[(data['type'] == "sell")]
                        #sells["datestamp"] = np.array(sells["timestamp"]).astype("datetime64[s]")
                        sellDates = (sells["datestamp"]).tolist()

                        volume = data["amount"].apply(float).tolist()

                        a.clear()

                        a.plot_date(buyDates,
                                    buys["price"],
                                    lightColor,
                                    label="buys")
                        a.plot_date(sellDates,
                                    sells["price"],
                                    darkColor,
                                    label="sells")

                        a2.fill_between(allDates,
                                        0,
                                        volume,
                                        facecolor=darkColor)

                        a.xaxis.set_major_locator(mticker.MaxNLocator(5))
                        a.xaxis.set_major_formatter(
                            mdates.DateFormatter("%Y-%m-%d %H:%M:%S"))
                        plt.setp(a.get_xticklabels(), visible=False)

                        a.legend(bbox_to_anchor=(0, 1.02, 1, .102),
                                 loc=3,
                                 ncol=2,
                                 borderaxespad=0)

                        title = "Bitfinex BTCUSD Prices\nLast Price: " + str(
                            data["price"][0])
                        a.set_title(title)
                        priceData = data['price'].apply(float).tolist()

                    if exchange == "Huobi":
                        a = plt.subplot2grid((6, 4), (0, 0),
                                             rowspan=6,
                                             colspan=4)
                        data = urllib.request.urlopen(
                            'http://seaofbtc.com/api/basic/price?key=1&tf=1d&exchange='
                            + programName).read()
                        data = data.decode()

                        data = json.loads(data)

                        dateStamp = np.array(data[0]).astype("datetime64[s]")
                        dateStamp = dateStamp.tolist()

                        df = pd.DataFrame({'Datetime': dateStamp})

                        df['Price'] = data[1]
                        df['Volume'] = data[2]
                        df['Symbol'] = "BTCUSD"

                        df['MPLDate'] = df['Datetime'].apply(
                            lambda date: mdates.date2num(date.to_pydatetime()))

                        df = df.set_index("Datetime")

                        lastPrice = df["Price"][-1]

                        a.plot_date(df['MPLDate'][-4500:],
                                    df['Price'][-4500:],
                                    lightColor,
                                    label="price")

                        a.xaxis.set_major_locator(mticker.MaxNLocator(5))
                        a.xaxis.set_major_formatter(
                            mdates.DateFormatter("%Y-%m-%d %H:%M:%S"))

                        title = "Huobi BTCUSD Prices\nLast Price: " + str(
                            lastPrice)
                        a.set_title(title)

                        priceData = df['price'].apply(float).tolist()

                except Exception as e:
                    print("Failed because of:", e)

            else:

                if DatCounter > 12:
                    try:
                        if exchange == "Huobi":
                            if topIndicator != "none":
                                a = plt.subplot2grid((6, 4), (1, 0),
                                                     rowspan=5,
                                                     colspan=4)
                                a2 = plt.subplot2grid((6, 4), (0, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)
                            else:
                                a = plt.subplot2grid((6, 4), (0, 0),
                                                     rowspan=6,
                                                     colspan=4)

                        else:
                            if topIndicator != "none" and bottomIndicator != "none":
                                # Main Graph
                                a = plt.subplot2grid((6, 4), (1, 0),
                                                     rowspan=3,
                                                     colspan=4)

                                # Volume
                                a2 = plt.subplot2grid((6, 4), (4, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)

                                # Bottom Indicator
                                a3 = plt.subplot2grid((6, 4), (5, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)

                                # Top Indicator
                                a0 = plt.subplot2grid((6, 4), (0, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)

                            elif topIndicator != "none":
                                # Main Graph
                                a = plt.subplot2grid((6, 4), (1, 0),
                                                     rowspan=4,
                                                     colspan=4)

                                # Volume
                                a2 = plt.subplot2grid((6, 4), (5, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)

                                # Top Indicator
                                a0 = plt.subplot2grid((6, 4), (0, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)

                            elif bottomIndicator != "none":

                                # Main Graph
                                a = plt.subplot2grid((6, 4), (0, 0),
                                                     rowspan=4,
                                                     colspan=4)

                                # Volume
                                a2 = plt.subplot2grid((6, 4), (4, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)

                                # Bottom Indicator
                                a3 = plt.subplot2grid((6, 4), (5, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)

                            else:
                                # Main Graph
                                a = plt.subplot2grid((6, 4), (0, 0),
                                                     rowspan=5,
                                                     colspan=4)

                                # Volume
                                a2 = plt.subplot2grid((6, 4), (5, 0),
                                                      sharex=a,
                                                      rowspan=1,
                                                      colspan=4)

                        data = urllib.request.urlopen(
                            "http://seaofbtc.com/api/basic/price?key=1&tf=" +
                            DataPace + "&exchange=" + programName).read()
                        data = data.decode()
                        data = json.loads(data)

                        dateStamp = np.array(data[0]).astype("datetime64[s]")
                        dateStamp = dateStamp.tolist()

                        df = pd.DataFrame({'Datetime': dateStamp})

                        df['Price'] = data[1]
                        df['Volume'] = data[2]
                        df['Symbol'] = 'BTCUSD'
                        df['MPLDate'] = df['Datetime'].apply(
                            lambda date: mdates.date2num(date.to_pydatetime()))
                        df = df.set_index("Datetime")

                        OHLC = df['Price'].resample(resampleSize, how="ohlc")
                        OHLC = OHLC.dropna()

                        volumeData = df['Volume'].resample(
                            resampleSize, how={'volume': 'sum'})

                        OHLC["dateCopy"] = OHLC.index
                        OHLC["MPLDates"] = OHLC["dateCopy"].apply(
                            lambda date: mdates.date2num(date.to_pydatetime()))

                        del OHLC["dateCopy"]

                        volumeData["dateCopy"] = volumeData.index
                        volumeData["MPLDates"] = volumeData["dateCopy"].apply(
                            lambda date: mdates.date2num(date.to_pydatetime()))

                        del volumeData["dateCopy"]

                        priceData = OHLC['close'].apply(float).tolist()

                        a.clear()

                        if middleIndicator != "none":
                            for eachMA in middleIndicator:
                                #ewma = pd.stats.moments.ewma
                                if eachMA[0] == "sma":
                                    sma = pd.rolling_mean(
                                        OHLC["close"], eachMA[1])
                                    label = str(eachMA[1]) + " SMA"
                                    a.plot(OHLC["MPLDates"], sma, label=label)

                                if eachMA[0] == "ema":
                                    ewma = pd.stats.moments.ewma
                                    label = str(eachMA[1]) + " EMA"
                                    a.plot(OHLC["MPLDates"],
                                           ewma(OHLC["close"], eachMA[1]),
                                           label=label)

                            a.legend(loc=0)

                        if topIndicator[0] == "rsi":
                            rsiIndicator(priceData, "top")

                        elif topIndicator == "macd":
                            try:
                                computeMACD(priceData, location="top")

                            except Exception as e:
                                print(str(e))

                        if bottomIndicator[0] == "rsi":
                            rsiIndicator(priceData, "bottom")

                        elif bottomIndicator == "macd":
                            try:
                                computeMACD(priceData, location="bottom")

                            except Exception as e:
                                print(str(e))

                        csticks = candlestick_ohlc(
                            a,
                            OHLC[["MPLDates", "open", "high", "low",
                                  "close"]].values,
                            width=candleWidth,
                            colorup=lightColor,
                            colordown=darkColor)
                        a.set_ylabel("Price")
                        if exchange != "Huobi":
                            a2.fill_between(volumeData["MPLDates"],
                                            0,
                                            volumeData['volume'],
                                            facecolor=darkColor)
                            a2.set_ylabel("Volume")

                        a.xaxis.set_major_locator(mticker.MaxNLocator(3))
                        a.xaxis.set_major_formatter(
                            mdates.DateFormatter('%Y-%m-%d %H:%M'))

                        if exchange != "Huobi":
                            plt.setp(a.get_xticklabels(), visible=False)

                        if topIndicator != "none":
                            plt.setp(a0.get_xticklabels(), visible=False)

                        if bottomIndicator != "none":
                            plt.setp(a2.get_xticklabels(), visible=False)

                        x = (len(OHLC['close'])) - 1

                        if DataPace == "1d":
                            title = exchange + " 1 Day Data with " + resampleSize + " Bars\nLast Price: " + str(
                                OHLC['close'][x])
                        if DataPace == "3d":
                            title = exchange + " 3 Day Data with " + resampleSize + " Bars\nLast Price: " + str(
                                OHLC['close'][x])
                        if DataPace == "7d":
                            title = exchange + " 7 Day Data with " + resampleSize + " Bars\nLast Price: " + str(
                                OHLC['close'][x])

                        if topIndicator != "none":
                            a0.set_title(title)

                        else:
                            a.set_title(title)

                        print("New Graph")
                        DatCounter = 0

                    except Exception as e:
                        print('failed in the non-tick animate:', str(e))
                        DatCounter = 9000

                else:
                    DatCounter += 1
Пример #43
0
def HMON_HYCOM_cross_transect(storm_id, cycle, tempt_lim_MAB, tempt_lim_GoM):

    #%%
    import numpy as np
    import matplotlib.pyplot as plt
    from datetime import datetime, timedelta
    import os
    import os.path
    import glob
    import cmocean
    from matplotlib.dates import date2num, num2date
    import xarray as xr

    import sys
    sys.path.append('/home/Maria.Aristizabal/NCEP_scripts/')
    from utils4HYCOM import readgrids
    #from utils4HYCOM import readdepth, readVar
    from utils4HYCOM2 import readBinz

    # Increase fontsize of labels globally
    plt.rc('xtick', labelsize=14)
    plt.rc('ytick', labelsize=14)
    plt.rc('legend', fontsize=14)

    #%%

    ti = datetime.today()
    ffig = '/home/Maria.Aristizabal/Figures/' + str(
        ti.year) + '/' + ti.strftime('%b-%d')
    folder_fig = ffig + '/' + storm_id + '_' + cycle + '/'

    os.system('mkdir ' + ffig)
    os.system('mkdir ' + folder_fig)

    #%% Bathymetry file

    bath_file = '/scratch2/NOS/nosofs/Maria.Aristizabal/bathymetry_files/GEBCO_2014_2D_-100.0_0.0_-10.0_70.0.nc'

    #%% Reading bathymetry data
    ncbath = xr.open_dataset(bath_file)
    bath_lat = ncbath.variables['lat'][:]
    bath_lon = ncbath.variables['lon'][:]
    bath_elev = ncbath.variables['elevation'][:]

    #%% folder and file names
    ti = datetime.today() - timedelta(1)

    folder_hmon_hycom = '/scratch2/NOS/nosofs/Maria.Aristizabal/HMON_HYCOM_' + storm_id + '_' + str(
        ti.year) + '/' + 'HMON_HYCOM_' + storm_id + '_' + cycle + '/'

    #%% Reading RTOFS grid
    grid_file = sorted(
        glob.glob(os.path.join(folder_hmon_hycom, '*regional.grid.*')))[0][:-2]

    #%% Reading RTOFS grid
    print('Retrieving coordinates from RTOFS')
    # Reading lat and lon
    #lines_grid = [line.rstrip() for line in open(grid_file+'.b')]
    lon_hycom = np.array(readgrids(grid_file, 'plon:', [0]))
    lat_hycom = np.array(readgrids(grid_file, 'plat:', [0]))

    #depth_HMON_HYCOM = np.asarray(readdepth(HMON_HYCOM_depth,'depth'))

    # Reading depths
    afiles = sorted(
        glob.glob(os.path.join(folder_hmon_hycom, '*hat10_3z' + '*.a')))
    lines = [line.rstrip() for line in open(afiles[0][:-2] + '.b')]
    z = []
    for line in lines[6:]:
        if line.split()[2] == 'temp':
            #print(line.split()[1])
            z.append(float(line.split()[1]))
    depth_HYCOM = np.asarray(z)

    time_HYCOM = []
    for x, file in enumerate(afiles):
        print(x)
        #lines=[line.rstrip() for line in open(file[:-2]+'.b')]

        #Reading time stamp
        year = int(file.split('/')[-1].split('.')[1][0:4])
        month = int(file.split('/')[-1].split('.')[1][4:6])
        day = int(file.split('/')[-1].split('.')[1][6:8])
        hour = int(file.split('/')[-1].split('.')[1][8:10])
        dt = int(file.split('/')[-1].split('.')[-2][1:])
        timestamp_HYCOM = date2num(datetime(year, month, day, hour)) + dt / 24
        time_HYCOM.append(num2date(timestamp_HYCOM))

    # Reading 3D variable from binary file
    oktime = 0  # first file
    temp_HMON_HYCOM = readBinz(afiles[oktime][:-2], '3z', 'temp')
    #salt_HMON_HYCOM = readBinz(afiles[oktime][:-2],'3z','salinity')

    #%%

    x1 = -74.1
    y1 = 39.4
    x2 = -73.0
    y2 = 38.6
    # Slope
    m = (y1 - y2) / (x1 - x2)
    # Intercept
    b = y1 - m * x1

    X = np.arange(x1, -72, 0.05)
    Y = b + m * X

    dist = np.sqrt((X - x1)**2 +
                   (Y - y1)**2) * 111  # approx along transect distance in km

    oklon = np.round(
        np.interp(X, lon_hycom[0, :] - 360,
                  np.arange(len(lon_hycom[0, :])))).astype(int)
    oklat = np.round(
        np.interp(Y, lat_hycom[:, 0],
                  np.arange(len(lat_hycom[:, 0])))).astype(int)

    trans_temp_HYCOM = temp_HMON_HYCOM[oklat, oklon, :]

    #min_valt = 4
    #max_valt = 27
    nlevelst = tempt_lim_MAB[1] - tempt_lim_MAB[0] + 1
    kw = dict(levels=np.linspace(tempt_lim_MAB[0], tempt_lim_MAB[1], nlevelst))

    fig, ax = plt.subplots(figsize=(9, 3))
    plt.contourf(dist,
                 -depth_HYCOM,
                 trans_temp_HYCOM.T,
                 cmap=cmocean.cm.thermal,
                 **kw)
    cbar = plt.colorbar()
    cbar.ax.tick_params(labelsize=16)
    plt.contour(dist, -depth_HYCOM, trans_temp_HYCOM.T, [26], color='k')
    cbar.ax.set_ylabel('($^\circ$C)', fontsize=14)
    cbar.ax.tick_params(labelsize=14)
    plt.ylabel('Depth (m)', fontsize=14)
    plt.xlabel('Along Transect Distance (km)', fontsize=14)
    plt.title('HMON-HYCOM Endurance Line ' + 'Storm ' + storm_id + ' Cycle ' +
              cycle + ' \n on ' + str(time_HYCOM[oktime])[0:13],
              fontsize=16)
    plt.ylim([-100, 0])
    plt.xlim([0, 200])

    file = folder_fig + 'HMON_HYCOM_temp_MAB_endurance_line_cycle_' + cycle
    plt.savefig(file, bbox_inches='tight', pad_inches=0.1)

    #%% Bathymetry GEBCO HYCOM domain
    kw = dict(levels=np.arange(-5000, 1, 200))

    plt.figure()
    plt.contour(bath_lon, bath_lat, bath_elev, levels=[0], colors='k')
    plt.contourf(bath_lon, bath_lat, bath_elev, cmap=cmocean.cm.topo, **kw)
    plt.plot(X, Y, '-k')
    plt.colorbar()
    plt.axis('scaled')
    plt.title('GEBCO Bathymetry')
    plt.xlim(-76, -70)
    plt.ylim(35, 42)

    file = folder_fig + 'MAB_transect'
    plt.savefig(file, bbox_inches='tight', pad_inches=0.1)

    #%%

    x1 = -90
    y1 = 20 + 52 / 60
    x2 = -90
    y2 = 30

    Y = np.arange(y1, y2, 0.05)
    X = np.tile(x1, len(Y))

    dist = np.sqrt((X - x1)**2 +
                   (Y - y1)**2) * 111  # approx along transect distance in km

    oklon = np.round(
        np.interp(X, lon_hycom[0, :] - 360,
                  np.arange(len(lon_hycom[0, :])))).astype(int)
    oklat = np.round(
        np.interp(Y, lat_hycom[:, 0],
                  np.arange(len(lat_hycom[:, 0])))).astype(int)

    trans_temp_HYCOM = temp_HMON_HYCOM[oklat, oklon, :]

    #min_valt = 12
    #max_valt = 32
    nlevelst = tempt_lim_GoM[1] - tempt_lim_GoM[0] + 1
    kw = dict(levels=np.linspace(tempt_lim_GoM[0], tempt_lim_GoM[1], nlevelst))

    fig, ax = plt.subplots(figsize=(9, 3))
    plt.contourf(dist,
                 -depth_HYCOM,
                 trans_temp_HYCOM.T,
                 cmap=cmocean.cm.thermal,
                 **kw)
    cbar = plt.colorbar()
    cbar.ax.tick_params(labelsize=16)
    plt.contour(dist, -depth_HYCOM, trans_temp_HYCOM.T, [26], color='k')
    cbar.ax.set_ylabel('($^\circ$C)', fontsize=14)
    cbar.ax.tick_params(labelsize=14)
    plt.ylabel('Depth (m)', fontsize=14)
    plt.xlabel('Along Transect Distance (km)', fontsize=14)
    plt.title('HMON-HYCOM Across GoMex ' + 'Storm ' + storm_id + ' Cycle ' +
              cycle + ' \n on ' + str(time_HYCOM[oktime])[0:13],
              fontsize=16)
    plt.ylim([-300, 0])
    #plt.xlim([0,200])

    file = folder_fig + 'HMON_HYCOM_temp_GoMex_across_cycle_' + cycle
    plt.savefig(file, bbox_inches='tight', pad_inches=0.1)

    #%% Bathymetry GEBCO HYCOM domain
    kw = dict(levels=np.arange(-5000, 1, 200))

    plt.figure()
    plt.contour(bath_lon, bath_lat, bath_elev, levels=[0], colors='k')
    plt.contourf(bath_lon, bath_lat, bath_elev, cmap=cmocean.cm.topo, **kw)
    plt.plot(X, Y, '-k')
    plt.colorbar()
    plt.axis('scaled')
    plt.title('GEBCO Bathymetry')
    plt.xlim(-98, -80)
    plt.ylim(18, 32)

    file = folder_fig + 'GoMex_transect'
    plt.savefig(file, bbox_inches='tight', pad_inches=0.1)
Пример #44
0
import datetime as DT
from matplotlib import pyplot as plt
from matplotlib.dates import date2num

data = [(DT.datetime.strptime('2016-10-03', "%Y-%m-%d"), 772.559998),
        (DT.datetime.strptime('2016-10-04', "%Y-%m-%d"), 776.429993),
        (DT.datetime.strptime('2016-10-05', "%Y-%m-%d"), 776.469971),
        (DT.datetime.strptime('2016-10-06', "%Y-%m-%d"), 776.859985),
        (DT.datetime.strptime('2016-10-07', "%Y-%m-%d"), 775.080017)]

x = [date2num(date) for (date, value) in data]
y = [value for (date, value) in data]

fig = plt.figure()

graph = fig.add_subplot(111)

graph.plot(x, y, 'r-o')

graph.set_xticks(x)

graph.set_xticklabels([date.strftime("%Y-%m-%d") for (date, value) in data])

plt.xlabel('Date')
plt.ylabel('Closing Value')
plt.title('Closing stock value of Alphabet Inc.')
plt.grid(linestyle='-', linewidth='0.5', color='blue')
plt.show()
Пример #45
0
def getTimestamp(fname):
    num = float(fname.split(".")[1]) / 10.0
    return md.date2num(dt.datetime.fromtimestamp(num))
Пример #46
0
for row in data:
    interval_start = row[0]
    interval_end = row[1]
    interval_mid = interval_start + (interval_end - interval_start) / 2
    fraction_of_mass_sampled = np.float32(row[6])
    fraction_of_mass_sampled_err = np.float32(row[7])
    mass_conc = np.float32(
        row[2]) / (np.float32(row[5]) * fraction_of_mass_sampled)
    mass_conc_err = np.float32(
        row[3]) / (np.float32(row[5]) * fraction_of_mass_sampled)
    numb_conc = np.float32(row[4]) / (np.float32(row[5]))

    timeseries_data.append([interval_mid, mass_conc, numb_conc])

time = [
    dates.date2num(datetime.utcfromtimestamp(row[0]))
    for row in timeseries_data
]
mass_concs = [row[1] for row in timeseries_data]
numb_concs = [row[2] for row in timeseries_data]

#plotting
hfmt = dates.DateFormatter('%Y%m%d %H:%M')
fig = plt.figure(figsize=(12, 10))

ax1 = plt.subplot2grid((2, 1), (0, 0))
ax2 = plt.subplot2grid((2, 1), (1, 0))

ax1.scatter(time, mass_concs, color='b', marker='o')
ax1.xaxis.set_major_formatter(hfmt)
ax1.set_ylabel('rBC mass concentration (ng/m3)')
def main():
    var_name_liquid = "I1"
    var_name_solid = "I2"
    #peirod of interest
    start_year = 1979
    end_year = 1988

    #spatial averaging will be done over upstream points to the stations
    selected_ids = [
        "092715", "080101", "074903", "050304", "080104", "081007", "061905",
        "041903", "040830", "093806", "090613", "081002", "093801", "080718"
    ]

    selected_ids = ["074903"]

    #simulation names corresponding to the paths
    sim_names = ["crcm5-hcd-rl", "crcm5-hcd-rl-intfl"]

    sim_labels = [x.upper() for x in sim_names]

    colors = ["blue", "violet"]

    layer_widths = [
        0.1, 0.2, 0.3, 0.4, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
        1.0, 3.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0
    ]

    layer_depths = np.cumsum(layer_widths)

    paths = [
        "/home/huziy/skynet3_rech1/from_guillimin/new_outputs/quebec_0.1_crcm5-hcd-rl_spinup",
        "/home/huziy/skynet3_rech1/from_guillimin/new_outputs/quebec_0.1_crcm5-hcd-rl-intfl_spinup2/Samples_all_in_one"
    ]

    seasons = [[12, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]

    season_names = ["DJF", "MAM", "JJA", "SON"]

    managers = [
        Crcm5ModelDataManager(samples_folder_path=path,
                              file_name_prefix="pm",
                              all_files_in_samples_folder=True,
                              need_cell_manager=(i == 0))
        for i, path in enumerate(paths)
    ]

    #share the cell manager
    a_data_manager = managers[0]
    assert isinstance(a_data_manager, Crcm5ModelDataManager)
    cell_manager = a_data_manager.cell_manager
    assert isinstance(cell_manager, CellManager)
    for m in managers[1:]:
        assert isinstance(m, Crcm5ModelDataManager)
        m.cell_manager = cell_manager

    #share the lake fraction field
    lake_fraction = a_data_manager.lake_fraction

    #selected_ids = ["092715", "080101", "074903", "050304", "080104", "081007", "061905",
    #                  "041903", "040830", "093806", "090613", "081002", "093801", "080718"]
    start_date = datetime(start_year, 1, 1)
    end_date = datetime(end_year, 12, 31)

    stations = cehq_station.read_station_data(selected_ids=selected_ids,
                                              start_date=start_date,
                                              end_date=end_date)

    #stations with corresponding model points
    station_to_mp = a_data_manager.get_dataless_model_points_for_stations(
        stations)

    #figure out levels in soil

    sim_label_to_profiles = {}
    for s, mp in station_to_mp.items():
        assert isinstance(mp, ModelPoint)
        mask = (mp.flow_in_mask == 1) & (lake_fraction < 0.6)
        fig = plt.figure()
        fmt = ScalarFormatter(useMathText=True)
        fmt.set_powerlimits([-2, 2])

        print(mp.ix, mp.jy, s.id)

        for m, label, color in zip(managers, sim_labels, colors):
            assert isinstance(m, Crcm5ModelDataManager)

            monthly_means_liquid = _get_cached_monthly_mean_fields(
                label, start_year, end_year, var_name_liquid)
            if monthly_means_liquid is None:
                monthly_means_liquid = m.get_monthly_climatology_of_3d_field(
                    var_name=var_name_liquid,
                    start_year=start_year,
                    end_year=end_year)
                _cache_monthly_mean_fields(monthly_means_liquid, label,
                                           start_year, end_year,
                                           var_name_liquid)

            monthly_means_solid = _get_cached_monthly_mean_fields(
                label, start_year, end_year, var_name_solid)
            if monthly_means_solid is None:
                monthly_means_solid = m.get_monthly_climatology_of_3d_field(
                    var_name=var_name_solid,
                    start_year=start_year,
                    end_year=end_year)
                _cache_monthly_mean_fields(monthly_means_solid, label,
                                           start_year, end_year,
                                           var_name_solid)

            profiles = [
                monthly_means_liquid[i][mask, :].mean(axis=0) +
                monthly_means_solid[i][mask, :].mean(axis=0) for i in range(12)
            ]

            sim_label_to_profiles[label] = np.array(profiles)

        x = [date2num(datetime(2001, month, 1)) for month in range(1, 13)]
        y = layer_depths

        y2d, x2d = np.meshgrid(y, x)
        delta = (sim_label_to_profiles[sim_labels[1]] -
                 sim_label_to_profiles[sim_labels[0]]
                 ) / sim_label_to_profiles[sim_labels[0]] * 100

        #delta = np.ma.masked_where(delta < 0.1, delta)

        cmap = my_colormaps.get_cmap_from_ncl_spec_file(
            path="colormap_files/BlueRed.rgb", ncolors=10)
        the_min = -6.0
        the_max = 6.0
        step = (the_max - the_min) / float(cmap.N)

        plt.pcolormesh(x2d[:, :8],
                       y2d[:, :8],
                       delta[:, :8],
                       cmap=cmap,
                       vmin=the_min,
                       vmax=the_max)  #, levels = np.arange(-6,7,1))
        plt.gca().invert_yaxis()
        plt.colorbar(ticks=np.arange(the_min, the_max + step, step))
        plt.gca().set_ylabel("Depth (m)")

        plt.gca().xaxis.set_major_formatter(DateFormatter("%b"))

        #fig.tight_layout()
        fig.savefig("soil_profile_upstream_of_{0}.pdf".format(s.id))

    pass
Пример #48
0
def HWRF_POM_cross_transect(storm_id, cycle, tempt_lim_MAB, tempt_lim_GoM):

    #%%
    from matplotlib import pyplot as plt
    import numpy as np
    import xarray as xr
    from matplotlib.dates import date2num, num2date
    from datetime import datetime, timedelta
    import os
    import os.path
    import glob
    import cmocean

    # Increase fontsize of labels globally
    plt.rc('xtick', labelsize=14)
    plt.rc('ytick', labelsize=14)
    plt.rc('legend', fontsize=14)

    #%%

    ti = datetime.today()
    ffig = '/home/Maria.Aristizabal/Figures/' + str(
        ti.year) + '/' + ti.strftime('%b-%d')
    folder_fig = ffig + '/' + storm_id + '_' + cycle + '/'

    os.system('mkdir ' + ffig)
    os.system('mkdir ' + folder_fig)

    #%% Bathymetry file

    bath_file = '/scratch2/NOS/nosofs/Maria.Aristizabal/bathymetry_files/GEBCO_2014_2D_-100.0_0.0_-10.0_70.0.nc'

    #%% Reading bathymetry data
    ncbath = xr.open_dataset(bath_file)
    bath_lat = ncbath.variables['lat'][:]
    bath_lon = ncbath.variables['lon'][:]
    bath_elev = ncbath.variables['elevation'][:]

    #%% folder and file names
    ti = datetime.today() - timedelta(1)

    folder_hwrf_pom = '/scratch2/NOS/nosofs/Maria.Aristizabal/HWRF_POM_' + storm_id + '_' + str(
        ti.year) + '/' + 'HWRF_POM_' + storm_id + '_' + cycle + '/'

    #%% Reading POM grid file
    grid_file = sorted(glob.glob(os.path.join(folder_hwrf_pom,
                                              '*grid*.nc')))[0]
    pom_grid = xr.open_dataset(grid_file)
    lon_pom = np.asarray(pom_grid['east_e'][:])
    lat_pom = np.asarray(pom_grid['north_e'][:])
    zlevc = np.asarray(pom_grid['zz'][:])
    topoz = np.asarray(pom_grid['h'][:])

    #%% Getting list of POM files
    ncfiles = sorted(glob.glob(os.path.join(folder_hwrf_pom, '*pom.0*.nc')))

    # Reading POM time
    time_pom = []
    for i, file in enumerate(ncfiles):
        print(i)
        pom = xr.open_dataset(file)
        tpom = pom['time'][:]
        timestamp_pom = date2num(tpom)[0]
        time_pom.append(num2date(timestamp_pom))

    time_POM = np.asarray(time_pom)

    oktime_POM = np.where(time_POM == time_POM[1])[0][0]  #second file

    #%% Figure temp transect along Endurance line

    x1 = -74.1
    y1 = 39.4
    x2 = -73.0
    y2 = 38.6
    # Slope
    m = (y1 - y2) / (x1 - x2)
    # Intercept
    b = y1 - m * x1

    X = np.arange(x1, -72, 0.05)
    Y = b + m * X

    dist = np.sqrt((X - x1)**2 +
                   (Y - y1)**2) * 111  # approx along transect distance in km

    oklon = np.round(np.interp(X, lon_pom[0, :],
                               np.arange(len(lon_pom[0, :])))).astype(int)
    oklat = np.round(np.interp(Y, lat_pom[:, 0],
                               np.arange(len(lat_pom[:, 0])))).astype(int)
    topoz_pom = np.asarray(topoz[oklat, oklon])
    zmatrix_POM = np.dot(topoz_pom.reshape(-1, 1), zlevc.reshape(1, -1)).T
    dist_matrix = np.tile(dist, (zmatrix_POM.shape[0], 1))

    trans_temp_POM = np.empty((zmatrix_POM.shape[0], zmatrix_POM.shape[1]))
    trans_temp_POM[:] = np.nan
    pom = xr.open_dataset(ncfiles[oktime_POM])
    for x in np.arange(len(X)):
        print(x)
        trans_temp_POM[:, x] = np.asarray(pom['t'][0, :, oklat[x], oklon[x]])

    #min_valt = 4
    #max_valt = 27
    nlevelst = tempt_lim_MAB[1] - tempt_lim_MAB[0] + 1
    kw = dict(levels=np.linspace(tempt_lim_MAB[0], tempt_lim_MAB[1], nlevelst))

    fig, ax = plt.subplots(figsize=(9, 5))
    plt.contourf(dist_matrix,
                 zmatrix_POM,
                 trans_temp_POM,
                 cmap=cmocean.cm.thermal,
                 **kw)
    cbar = plt.colorbar()
    cbar.ax.tick_params(labelsize=16)
    plt.contour(dist_matrix, zmatrix_POM, trans_temp_POM, [26], color='k')
    cbar.ax.set_ylabel('($^\circ$C)', fontsize=14)
    cbar.ax.tick_params(labelsize=14)
    plt.title('HWRF-POM Endurance Line MAB ' + 'Storm ' + storm_id +
              ' Cycle ' + cycle + ' \n on ' + str(time_POM[oktime_POM])[0:13],
              fontsize=16)
    plt.ylim([-100, 0])
    plt.xlim([0, 200])
    ax.set_ylabel('Depth (m)', fontsize=14)
    ax.set_xlabel('Along Transect Distance (km)', fontsize=14)

    file = folder_fig + 'HWRF_POM_temp_MAB_endurance_line_cycle_' + cycle
    plt.savefig(file, bbox_inches='tight', pad_inches=0.1)

    #%% Bathymetry GEBCO HYCOM domain
    kw = dict(levels=np.arange(-5000, 1, 200))

    plt.figure()
    plt.contour(bath_lon, bath_lat, bath_elev, levels=[0], colors='k')
    plt.contourf(bath_lon, bath_lat, bath_elev, cmap=cmocean.cm.topo, **kw)
    plt.plot(X, Y, '-k')
    plt.colorbar()
    plt.axis('scaled')
    plt.title('GEBCO Bathymetry')
    plt.xlim(-76, -70)
    plt.ylim(35, 42)

    file = folder_fig + 'MAB_transect'
    plt.savefig(file, bbox_inches='tight', pad_inches=0.1)

    #%% Figure temp transect across GoMex

    x1 = -90
    y1 = 20 + 52 / 60
    x2 = -90
    y2 = 30

    Y = np.arange(y1, y2, 0.05)
    X = np.tile(x1, len(Y))

    dist = np.sqrt((X - x1)**2 +
                   (Y - y1)**2) * 111  # approx along transect distance in km

    oklon = np.round(np.interp(X, lon_pom[0, :],
                               np.arange(len(lon_pom[0, :])))).astype(int)
    oklat = np.round(np.interp(Y, lat_pom[:, 0],
                               np.arange(len(lat_pom[:, 0])))).astype(int)
    topoz_pom = np.asarray(topoz[oklat, oklon])
    zmatrix_POM = np.dot(topoz_pom.reshape(-1, 1), zlevc.reshape(1, -1)).T
    dist_matrix = np.tile(dist, (zmatrix_POM.shape[0], 1))

    trans_temp_POM = np.empty((zmatrix_POM.shape[0], zmatrix_POM.shape[1]))
    trans_temp_POM[:] = np.nan
    pom = xr.open_dataset(ncfiles[oktime_POM])
    for x in np.arange(len(X)):
        print(x)
        trans_temp_POM[:, x] = np.asarray(pom['t'][0, :, oklat[x], oklon[x]])

    #min_valt = 12
    #max_valt = 32
    nlevelst = tempt_lim_GoM[1] - tempt_lim_GoM[0] + 1
    kw = dict(levels=np.linspace(tempt_lim_GoM[0], tempt_lim_GoM[1], nlevelst))

    fig, ax = plt.subplots(figsize=(9, 3))
    plt.contourf(dist_matrix,
                 zmatrix_POM,
                 trans_temp_POM,
                 cmap=cmocean.cm.thermal,
                 **kw)
    cbar = plt.colorbar()
    cbar.ax.tick_params(labelsize=16)
    plt.contour(dist_matrix, zmatrix_POM, trans_temp_POM, [26], color='k')
    cbar.ax.set_ylabel('($^\circ$C)', fontsize=14)
    cbar.ax.tick_params(labelsize=14)
    plt.title('HWRF-POM  Across GoMex ' + 'Storm ' + storm_id + ' Cycle ' +
              ' \n on ' + str(time_POM[oktime_POM])[0:13],
              fontsize=16)
    plt.ylim([-300, 0])
    #plt.xlim([0,200])
    ax.set_ylabel('Depth (m)', fontsize=14)
    ax.set_xlabel('Along Transect Distance (km)', fontsize=14)

    file = folder_fig + 'HWRF_POM_temp_GoMex_across_cycle_' + cycle
    plt.savefig(file, bbox_inches='tight', pad_inches=0.1)

    #%% Bathymetry GEBCO HYCOM domain
    kw = dict(levels=np.arange(-5000, 1, 200))

    plt.figure()
    plt.contour(bath_lon, bath_lat, bath_elev, levels=[0], colors='k')
    plt.contourf(bath_lon, bath_lat, bath_elev, cmap=cmocean.cm.topo, **kw)
    plt.plot(X, Y, '-k')
    plt.colorbar()
    plt.axis('scaled')
    plt.title('GEBCO Bathymetry')
    plt.xlim(-98, -80)
    plt.ylim(18, 32)

    file = folder_fig + 'GoMex_transect'
    plt.savefig(file, bbox_inches='tight', pad_inches=0.1)
Пример #49
0
#設定K線初始變數
STime = TimetoNumber('08450000')
#設定K線週期
Cycle = 6000
OHLC = []
lastAmount = 0

#計算每分鐘OHLC
for i in I020:
    time = TimetoNumber(i[0])
    price = int(i[4])
    amount = int(i[6])
    if len(OHLC) == 0:
        OHLC += [[
            mdates.date2num(
                datetime.datetime.strptime(NumbertoTime(STime + Cycle),
                                           "%H%M%S")), price, price, price,
            price, 0
        ]]
    if time < STime + Cycle:
        if price > OHLC[-1][2]:
            OHLC[-1][2] = price
        if price < OHLC[-1][3]:
            OHLC[-1][3] = price
        OHLC[-1][4] = price
    else:
        OHLC[-1][5] = amount - lastAmount
        lastAmount = amount
        STime += Cycle
        OHLC += [[
            mdates.date2num(
Пример #50
0
    176758,
    '2015-03-04',
    825,
    176958,
    '2015-04-04',
    830,
    176926,
]

# Extract the dates from the data array
date_strings = data[0::3]

# Convert date strings into numbers
date_nums = []
for d in date_strings:
    date_nums.append(date2num(datetime.strptime(d, '%Y-%m-%d')))

# Extract number of files from data array
n_files = data[1::3]

# Extract number of lines of code from data array
n_lines = data[2::3]

# Get a reference to the figure
fig = plt.figure()

# 111 is equivalent to Matlab's subplot(1,1,1) command
ax1 = fig.add_subplot(111)
ax1.plot(date_nums, n_files, 'bo-')
ax1.set_ylabel('Files (blue circles)')
    if tend.day < 10:
        fol = 'rtofs.' + str(tini.year) + str(tini.month) + '0' + str(tini.day)
    else:
        fol = 'rtofs.' + str(tini.year) + str(tini.month) + str(tini.day)

ncRTOFS = xr.open_dataset(folder_RTOFS + fol + '/' + nc_files_RTOFS[0])
latRTOFS = np.asarray(ncRTOFS.Latitude[:])
lonRTOFS = np.asarray(ncRTOFS.Longitude[:])
depthRTOFS = np.asarray(ncRTOFS.Depth[:])

tRTOFS = []
for t in np.arange(len(nc_files_RTOFS)):
    ncRTOFS = xr.open_dataset(folder_RTOFS + fol + '/' + nc_files_RTOFS[t])
    tRTOFS.append(np.asarray(ncRTOFS.MT[:])[0])

tRTOFS = np.asarray([mdates.num2date(mdates.date2num(tRTOFS[t])) \
          for t in np.arange(len(nc_files_RTOFS))])

#%% Downloading and reading Copernicus grid
COP_grid = xr.open_dataset(ncCOP_global)

latCOP_glob = COP_grid.latitude[:]
lonCOP_glob = COP_grid.longitude[:]

#%% Reading bathymetry data
ncbath = xr.open_dataset(bath_file)
bath_lat = ncbath.variables['lat'][:]
bath_lon = ncbath.variables['lon'][:]
bath_elev = ncbath.variables['elevation'][:]

#%%    
Пример #52
0
         label='Average Price',
         linestyle='--')
plt.title('Stock of Moving Average Envelopes')
plt.ylabel('Price')
plt.xlabel('Date')
plt.legend(loc='best')
plt.show()

# ## Candlestick with MAE
from matplotlib import dates as mdates

dfc = df.copy()
dfc['VolumePositive'] = dfc['Open'] < dfc['Adj Close']
#dfc = dfc.dropna()
dfc = dfc.reset_index()
dfc['Date'] = mdates.date2num(dfc['Date'].tolist())
from mplfinance.original_flavor import candlestick_ohlc

fig = plt.figure(figsize=(14, 7))
ax1 = plt.subplot(111)
candlestick_ohlc(ax1,
                 dfc.values,
                 width=0.5,
                 colorup='g',
                 colordown='r',
                 alpha=1.0)
ax1.plot(df['Upper_Envelope'], color='blue')
ax1.plot(df['Lower_Envelope'], color='red')
ax1.plot(df['Adj Close'].rolling(20).mean(), color='orange')
ax1.xaxis_date()
ax1.xaxis.set_major_formatter(mdates.DateFormatter('%d-%m-%Y'))
Пример #53
0
"""
==============
Load Converter
==============

"""

import dateutil.parser
from matplotlib import cbook, dates
import matplotlib.pyplot as plt
import numpy as np


datafile = cbook.get_sample_data('msft.csv', asfileobj=False)
print('loading', datafile)

data = np.genfromtxt(
    datafile, delimiter=',', names=True,
    converters={0: lambda s: dates.date2num(dateutil.parser.parse(s))})

fig, ax = plt.subplots()
ax.plot_date(data['Date'], data['High'], '-')
fig.autofmt_xdate()
plt.show()
Пример #54
0
def plot_tog():
	fig = plt.figure(figsize=(7, 10))

	gss = gridspec.GridSpec(nrows=3, ncols=1, height_ratios=[1, 2,2])
	ax1 = plt.subplot(gss[0])
	ax2 = plt.subplot(gss[1])
	ax3 = plt.subplot(gss[2], sharex=ax2)

	ax1.plot(gl, color='r', label='GOES 1-8$\mathrm{\AA}$')
	ax1.plot(gs, color='b', label='GOES 1-8$\mathrm{\AA}$')
	ax1.set_yscale('log')
	ax1.set_xlim(flare_ts, flare_te)
	ax1.xaxis.set_minor_locator(dates.SecondLocator(interval=10))
	ax1.xaxis.set_major_locator(dates.MinuteLocator(interval=1))
	ax1.legend(loc='upper right')
	ax1.tick_params(labelbottom=False, which='both', direction='in')
	ax1.set_ylabel('Flux (Wm$^{-2}$)')
	ax1.axvline(pul_ts, color='k')
	ax1.axvline(pul_te, color='k')


	ax2.plot(norp17, label='NoRP 17GHz', color='darkred', drawstyle='steps-mid')
	ax2.plot(norp9, label='NoRP 9GHz', color='darkblue', drawstyle='steps-mid')
	ax2.legend(loc='upper right')
	ax2.set_ylabel('Flux (SFU)')
	ax2.set_ylim(0, 200)


	x1 = dates.date2num(datetime.datetime.strptime(pul_ts, '%Y-%m-%d %H:%M:%S')) # start time
	x2 = dates.date2num(datetime.datetime.strptime(pul_te, '%Y-%m-%d %H:%M:%S')) # end time

	xyA = (x1, -0.01)
	xyB = (0.0, 1)  # x and y in axes coordinates
	coordsA = ax1.get_xaxis_transform() # x in data coords, y in axes coords
	coordsB = "axes fraction"
	con_start = ConnectionPatch(xyA=xyA, xyB=xyB, coordsA=coordsA, coordsB=coordsB,
						        axesA=ax1, axesB=ax2,
	                            arrowstyle="-")
	xyC = (x2, -0.01)
	xyD = (1, 1)  # x and y in axes coordinates
	coordsC = ax1.get_xaxis_transform() # x in data coords, y in axes coords
	coordsD = "axes fraction"
	con_end = ConnectionPatch(xyA=xyC, xyB=xyD, coordsA=coordsC, coordsB=coordsD,
						     axesA=ax1, axesB=ax2,
	                         arrowstyle="-")



	ax2.add_artist(con_start)
	ax2.add_artist(con_end)


	#ax3 = ax2.twinx()
	ax3.plot(rhessi_2535, drawstyle='steps-mid', label='RHESSI 25-35keV', color='grey', lw=0.8)
	ax3.plot(rhessi_35100, drawstyle='steps-mid', label='RHESSI 35-100keV', color='k', lw=0.8)
	ax3.legend(loc = 'upper right')
	ax3.set_ylabel('Counts det$^{-1}$ s$^{-1}$')


	ax3.set_xlabel('Time (UT) 2014-06-11')
	ax3.set_xlim(pul_ts, pul_te)
	ax2.xaxis.set_minor_locator(dates.SecondLocator(interval=10))
	ax2.xaxis.set_major_locator(dates.MinuteLocator(interval=1))
	ax2.xaxis.set_major_formatter(dates.DateFormatter('%H:%M:%S'))
	ax2.tick_params(which='both', direction='in', labelbottom=False)
	#ax3.xaxis.set_tick_params(rotation=45, which='both', direction='in')
	ax3.xaxis.set_tick_params(which='both', direction='in')


	plt.tight_layout()
	plt.subplots_adjust(hspace=0.1)
	plt.savefig('overview_test.png', dpi=200)
	plt.close()
Пример #55
0
#開始進行內外盤計算
for i in range(1, len(Data)):
    time = datetime.datetime.strptime(Data[i][0], "%H%M%S%f")
    price = float(Data[i][2])
    qty = int(Data[i][3])
    value = price * 1000 * qty
    if value > BigValue:
        BigTrade.append([time, price])

# print(BigTrade)

#開始進行繪圖
#取得轉換時間字串至時間格式
Time = [datetime.datetime.strptime(line[0], "%H%M%S%f") for line in Data]
#將datetime時間格式轉換為繪圖專用的時間格式,透過mdates.date2num函數
Time1 = [mdates.date2num(line) for line in Time]
#價格由字串轉數值
Price = [float(line[2]) for line in Data]

#定義圖表物件
ax = plt.subplot(111)

#定義title
plt.title('Price&BigTrade Line')

# 繪製價格折線圖
ax.plot_date(Time1, Price, 'k-')

if len(BigTrade) != 0:
    #取得轉換時間字串至時間格式
    STime = [line[0] for line in BigTrade]
Пример #56
0
def MpfPlotWave(ticker):
    # assert ticker is not empty
    if len(ticker) == 0:
        return

    start = datetime(2019, 2, 9)
    end = datetime(2020, 2, 11)

    # values that can be parameterized
    intEmaPeriod = 34
    intBars = 90

    row = 0
    for i in ticker:
        ohlc = get_historical_data(i,
                                   start,
                                   end,
                                   output_format='pandas',
                                   token=jsnIEX['iextoken'])
        ohlc.columns = ["Open", "High", "Low", "Close", "Volume"]
        if (intBars + intEmaPeriod > len(ohlc)):
            print("Error: Bars + EmaPeriod exceeds ohlc " +
                  str(len(ohlc) - intBars - intEmaPeriod))
            return

        hEma = ohlc['High'].ewm(intEmaPeriod).mean()
        cEma = ohlc['Close'].ewm(intEmaPeriod).mean()
        lEma = ohlc['Low'].ewm(intEmaPeriod).mean()

        # extract OHLC into a list of lists
        lohlc = ohlc[['Open', 'High', 'Low', 'Close']].values.tolist()

        # convert dates in datetime format to mathplotlib dates
        mdates = dates.date2num(ohlc.index)

        # prepare ohlc in mathplotlib format
        mohlc = [[mdates[i]] + lohlc[i] for i in range(len(mdates))]

        # set default font sizes
        params = {'axes.labelsize': 20, 'axes.titlesize': 24}
        pyplot.rcParams.update(params)

        fig, ax = pyplot.subplots(figsize=(24, 24))

        # set default tick sizes
        ax.tick_params(axis='both', which='major', labelsize=20)
        ax.tick_params(axis='both', which='minor', labelsize=18)

        # mpfold.plot_day_summary_ohlc(ax, mohlc[-50:], ticksize=5, colorup='#77d879', colordown='#db3f3f') # alternatively, use a barchart
        mpfold.candlestick_ohlc(ax,
                                mohlc[-intBars:],
                                width=0.4,
                                colorup='#77d879',
                                colordown='#db3f3f')
        ax.plot(hEma[-intBars:],
                color='red',
                linewidth=2,
                label='high, ' + str(intEmaPeriod) + '-Day EMA')
        ax.plot(cEma[-intBars:],
                color='green',
                linewidth=2,
                label='close, ' + str(intEmaPeriod) + '-Day EMA')
        ax.plot(lEma[-intBars:],
                color='blue',
                linewidth=2,
                label='low, ' + str(intEmaPeriod) + '-Day EMA')

        ax.set_xlabel('Date')
        ax.set_ylabel('Price')
        ax.set_title(i + ' Chart with ' + str(intEmaPeriod) + '-Day EMA Wave')
        ax.legend(fontsize=20)
        ax.xaxis.set_major_formatter(dates.DateFormatter('%b %d'))
        fig.autofmt_xdate()
                okd = np.logical_and(depthg_gridded >= np.min(depthf[okt]),
                                     depthg_gridded < np.max(depthf[okt]))
                tempg_gridded[okd, t] = np.interp(depthg_gridded[okd],
                                                  depthf[okt], tempf[okt])

            oks = np.isfinite(saltf)
            if np.sum(oks) < 3:
                saltg_gridded[:, t] = np.nan
            else:
                okd = np.logical_and(depthg_gridded >= np.min(depthf[oks]),
                                     depthg_gridded < np.max(depthf[oks]))
                saltg_gridded[okd, t] = np.interp(depthg_gridded[okd],
                                                  depthf[oks], saltf[oks])

        # Narrowing time window of Doppio to coincide with glider time window
        tmin = mdates.num2date(mdates.date2num(timeg[0]))
        tmax = mdates.num2date(mdates.date2num(timeg[-1]))

        # Changing times to timestamp
        ttdoppio = [
            datetime(tdoppio[i].year, tdoppio[i].month, tdoppio[i].day,
                     tdoppio[i].hour) for i in np.arange(len(tdoppio))
        ]
        ttstamp_doppio = [
            mdates.date2num(ttdoppio[i]) for i in np.arange(len(ttdoppio))
        ]
        tstamp_glider = [
            mdates.date2num(timeg[i]) for i in np.arange(len(timeg))
        ]

        # oktime_doppio = np.where(np.logical_and(tdoppio >= tmin,tdoppio <= tmax))
Пример #58
0
    def plot3Axes(self,
                  figNum,
                  time,
                  data,
                  title='',
                  units='',
                  xlabel='Time (s)',
                  options='',
                  xlim=None,
                  ylim=None):
        fig = plt.figure(figNum)
        #     plt.cla()

        if title:
            self.title = title
        if units:
            self.units = units
        if self.preTitle:
            fig.canvas.set_window_title("Figure %d - %s" %
                                        (figNum, self.preTitle))
        if not figNum in self.sharex.keys():
            self.sharex[figNum] = plt.subplot(3, 1, 1)
#             plt.plot(time, data[:,0], options)

# Plot 1
        subplt = plt.subplot(3, 1, 1, sharex=self.sharex[figNum])
        #         plt.hold(True);
        plt.grid(True)
        plt.title("%s" % (self.title))
        plt.ylabel('(%s)' % (self.units))
        plt.xlabel(xlabel)
        plt.margins(0.04)
        if xlim:
            subplt.set_xlim(xlim)
        if ylim:
            subplt.set_ylim(ylim)
        if self.timeIsUtc:
            dates = [dt.datetime.fromtimestamp(ts) for ts in time]
            datenums = md.date2num(dates)
            #         plt.subplots_adjust(bottom=0.2)
            plt.xticks(rotation=25)
            ax = plt.gca()
            if self.timeIsUtc == 2:
                xfmt = md.DateFormatter('%H:%M:%S.%f')
            else:
                xfmt = md.DateFormatter('%H:%M:%S')
            ax.xaxis.set_major_formatter(xfmt)
            plt.plot(datenums, data[:, 0], options)
        else:
            plt.plot(time, data[:, 0], options)

        # Plot 2
        subplt = plt.subplot(3, 1, 2, sharex=self.sharex[figNum])
        #         plt.hold(True);
        plt.grid(True)
        plt.ylabel('(%s)' % (self.units))
        plt.xlabel(xlabel)
        plt.margins(0.04)
        if xlim:
            subplt.set_xlim(xlim)
        if ylim:
            subplt.set_ylim(ylim)
        if self.timeIsUtc:
            dates = [dt.datetime.fromtimestamp(ts) for ts in time]
            datenums = md.date2num(dates)
            #         plt.subplots_adjust(bottom=0.2)
            plt.xticks(rotation=25)
            ax = plt.gca()
            if self.timeIsUtc == 2:
                xfmt = md.DateFormatter('%H:%M:%S.%f')
            else:
                xfmt = md.DateFormatter('%H:%M:%S')
            ax.xaxis.set_major_formatter(xfmt)
            plt.plot(datenums, data[:, 1], options)
        else:
            plt.plot(time, data[:, 1], options)

        # Plot 3
        subplt = plt.subplot(3, 1, 3, sharex=self.sharex[figNum])
        #         plt.hold(True);
        plt.grid(True)
        plt.ylabel('(%s)' % (self.units))
        plt.xlabel(xlabel)
        plt.margins(0.04)
        if xlim:
            subplt.set_xlim(xlim)
        if ylim:
            subplt.set_ylim(ylim)
        if self.timeIsUtc:
            dates = [dt.datetime.fromtimestamp(ts) for ts in time]
            datenums = md.date2num(dates)
            #         plt.subplots_adjust(bottom=0.2)
            plt.xticks(rotation=25)
            ax = plt.gca()
            if self.timeIsUtc == 2:
                xfmt = md.DateFormatter('%H:%M:%S.%f')
            else:
                xfmt = md.DateFormatter('%H:%M:%S')
            ax.xaxis.set_major_formatter(xfmt)
            plt.plot(datenums, data[:, 2], options)
        else:
            plt.plot(time, data[:, 2], options)

    #         legend(['desire','actual','e/10','e2/10'])
        return fig
Пример #59
0
    def __init__(self, master):
        # load data
        datetime_list, barpress_list = [], []
        datetime_re = re.compile(r'[\d]{2,4}')  # regex to get datetime info

        for year in range(2012, 2016):
            file = Path(f'{DATA_FOLDER}/Environmental_Data_Deep_Moor_{year}.txt')
            print('Loading {0}'.format(file.name))
            for row in DictReader(file.open('r'), delimiter='\t'):
                barpress_list.append(float(row['Barometric_Press']))
                datetime_list.append(date2num(
                    datetime(*list(map(int, datetime_re.findall(row['date       time    ']))))))

        self.datetime_array = np.array(datetime_list)
        self.barpress_array = np.array(barpress_list)

        # build the gui
        master.title('Weather Statistics')
        master.resizable(True, True)

        # maximize Tkinter windows
        # ref: https://stackoverflow.com/questions/15981000/tkinter-python-maximize-window
        try:
            master.state('zoomed')
        except (TclError):
            size = master.maxsize()
            master.geometry('{}x{}+0+0'.format(*size))

        # draw the figure
        matplotlib.rc('font', size=18)
        figure = Figure()
        figure.set_facecolor((0, 0, 0, 0))
        self.a = figure.add_subplot(111)
        self.canvas = FigureCanvasTkAgg(figure, master)
        self.canvas.draw()

        # add toolbar
        toolbar_frame = ttk.Frame(master)  # needed to put navbar above plot
        toolbar = NavigationToolbar2Tk(self.canvas, toolbar_frame)
        toolbar.update()
        toolbar_frame.pack(side=TOP, fill=X, expand=0)
        self.canvas._tkcanvas.pack(fill=BOTH, expand=1)

        controls_frame = ttk.Frame(master)
        controls_frame.pack()

        ttk.Label(controls_frame, text='Start', font='Arial 18 bold').grid(row=0, column=0, pady=5)
        ttk.Label(controls_frame, text='(YYYY-MM-DD HH:MM:SS)', font='Courier 12').grid(row=1, column=0, padx=50, sticky='s')
        self.start = StringVar()
        ttk.Entry(controls_frame, width=19, textvariable=self.start, font='Courier 12').grid(row=2, column=0, sticky='n')
        self.start.set(str(num2date(self.datetime_array[0]))[0:19])

        ttk.Label(controls_frame, text='End', font='Arial 18 bold').grid(row=0, column=1, pady=5)
        ttk.Label(controls_frame, text='(YYYY-MM-DD HH:MM:SS)', font='Courier 12').grid(row=1, column=1, padx=50, sticky='s')
        self.end = StringVar()
        ttk.Entry(controls_frame, width=19, textvariable=self.end, font='Courier 12').grid(row=2, column=1, sticky='n')
        self.end.set(str(num2date(self.datetime_array[-1]))[0:19])

        # add button for update time range
        ttk.Button(controls_frame, text='Update', command=self._update).grid(row=3, column=0, columnspan=2, pady=10)
        ttk.Style().configure('TButton', font='Arial 18 bold')

        # call _update() to draw default figure
        self._update()
Пример #60
0
def reload_signals_from_timestamp(patientSigDF, timeStamp=None, deltaIdx=0):
    """
    Reload signals from processed npy file corresponding to timepoint of interest (or file that is deltaIdx files ahead or beind timepoint of interest)
    timeStamp can be pandas Timestamp object, datetime object, 6-tuple datetimes or UTC time integer
    eg. 2:30:47 pm on 17 January 2015 in 6-tuple is: (2015, 1, 17, 14, 30, 47)

    patientSigDF is the patient specific dataframe that is generated undert the subjects.Patient class in ecogtools.recordingparams
    """

    if timeStamp is None:
        loadIdx = 0
    else:
        if isinstance(timeStamp, pd.tslib.Timestamp) or isinstance(
                timeStamp, datetime.datetime):
            timepoint = timeStamp
        elif isinstance(timeStamp, int) or isinstance(
                timeStamp, float) or isinstance(timeStamp, tuple):
            timepoint = utils.convert_timestamp([timeStamp])['datetime']

        sigIdx_temp = np.where((patientSigDF['startT'] <= timepoint)
                               & (patientSigDF['endT'] >= timepoint))[0]
        if len(sigIdx_temp) == 0:
            print('No data at time {0}'.format(timepoint))
            loadIdx = None
        else:
            sigIdx = np.where((patientSigDF['startT'] <= timepoint)
                              & (patientSigDF['endT'] >= timepoint))[0][0]
            loadIdx = sigIdx + deltaIdx

    tAxis = {}

    if loadIdx is not None and loadIdx <= len(patientSigDF['signalsFile']):
        signals = np.load(patientSigDF['signalsFile'][loadIdx], mmap_mode='r')
        tAxis['UTC'] = np.load(patientSigDF['signalsFile'][loadIdx].replace(
            '_signal.npy', '_time.npy'),
                               mmap_mode='r')

        # Seconds since start of recording
        nTimePoints = len(tAxis['UTC'])

        #sampFq = round((nTimePoints)/(tAxis['UTC'][-1]-tAxis['UTC'][0]))
        sampFq = patientSigDF['sampFq'][loadIdx]
        nSec = nTimePoints / float(sampFq)
        tAxis['sec'] = np.linspace(0, nSec, nTimePoints)

        # matplotlib time axis (days since 0001-01-01 UTC plus 1)

        startObj = datetime.datetime.fromtimestamp(tAxis['UTC'][0])
        endObj = datetime.datetime.fromtimestamp(tAxis['UTC'][-1])

        mplStart = mdates.date2num(startObj)
        mplEnd = mdates.date2num(endObj)
        tAxis['matplotlib'] = np.linspace(mplStart, mplEnd, nTimePoints)

        fileID = patientSigDF['signalsFile'][loadIdx]
    else:
        print('Index out of bounds')
        signals = None
        tAxis = None
        sampFq = None
        fileID = None

    return {'signals': signals, 'tAxis': tAxis, 'sampFq': sampFq}, fileID