Beispiel #1
0
def test_drange():
    """
    This test should check if drange works as expected, and if all the
    rounding errors are fixed
    """
    start = datetime.datetime(2011, 1, 1, tzinfo=mdates.UTC)
    end = datetime.datetime(2011, 1, 2, tzinfo=mdates.UTC)
    delta = datetime.timedelta(hours=1)
    # We expect 24 values in drange(start, end, delta), because drange returns
    # dates from an half open interval [start, end)
    assert_equal(24, len(mdates.drange(start, end, delta)))

    # if end is a little bit later, we expect the range to contain one element
    # more
    end = end + datetime.timedelta(microseconds=1)
    assert_equal(25, len(mdates.drange(start, end, delta)))

    # reset end
    end = datetime.datetime(2011, 1, 2, tzinfo=mdates.UTC)

    # and tst drange with "complicated" floats:
    # 4 hours = 1/6 day, this is an "dangerous" float
    delta = datetime.timedelta(hours=4)
    daterange = mdates.drange(start, end, delta)
    assert_equal(6, len(daterange))
    assert_equal(mdates.num2date(daterange[-1]), end - delta)
Beispiel #2
0
def test_drange():
    """
    This test should check if drange works as expected, and if all the
    rounding errors are fixed
    """
    start = datetime.datetime(2011, 1, 1, tzinfo=mdates.UTC)
    end = datetime.datetime(2011, 1, 2, tzinfo=mdates.UTC)
    delta = datetime.timedelta(hours=1)
    # We expect 24 values in drange(start, end, delta), because drange returns
    # dates from an half open interval [start, end)
    assert len(mdates.drange(start, end, delta)) == 24

    # if end is a little bit later, we expect the range to contain one element
    # more
    end = end + datetime.timedelta(microseconds=1)
    assert len(mdates.drange(start, end, delta)) == 25

    # reset end
    end = datetime.datetime(2011, 1, 2, tzinfo=mdates.UTC)

    # and tst drange with "complicated" floats:
    # 4 hours = 1/6 day, this is an "dangerous" float
    delta = datetime.timedelta(hours=4)
    daterange = mdates.drange(start, end, delta)
    assert len(daterange) == 6
    assert mdates.num2date(daterange[-1]) == (end - delta)
Beispiel #3
0
def main():
    parser = argparse.ArgumentParser()

    # adding the arguments
    parser.add_argument(
        "-e", default=datetime.today().isoformat(timespec='hours')[:-3])
    parser.add_argument("-t", default='1y')
    parser.add_argument("-i", default='^GDAXI')

    # Parse and print the results
    args = parser.parse_args()
    print(args)

    # compute timeframe
    if args.t == '1y':
        timeframe = timedelta(days=365)
    elif args.t == '5y':
        timeframe = timedelta(days=365 * 5)
    elif args.t == '10y':
        timeframe = timedelta(days=365 * 10)
    elif args.t == '6m':
        timeframe = timedelta(days=30 * 6)
    elif args.t == '3m':
        timeframe = timedelta(days=30 * 3)
    elif args.t == '1m':
        timeframe = timedelta(days=30)
    else:
        timeframe = timedelta(days=365)

    tickerSymbol = args.i
    end = args.e
    start = (datetime.fromisoformat(end) -
             timeframe).isoformat(timespec='hours')[:-3]

    # getting the financial data from yfinance
    tickerData = yf.Ticker(tickerSymbol)

    # selecting the correct timeperiod
    tickerDf = tickerData.history(period='1s', start=start, end=end)

    start = datetime.fromisoformat(start)
    end = datetime.fromisoformat(end)

    # plotting the data green if overall close goes up and red if down
    if tickerDf.iloc[0]['Close'] < tickerDf.iloc[-1]['Close']:
        plx.plot(drange(start, end, timedelta(days=1)),
                 tickerDf['Close'],
                 line_color='green')
    else:
        plx.plot(drange(start, end, timedelta(days=1)),
                 tickerDf['Close'],
                 line_color='red')

    plx.show()
Beispiel #4
0
def gen_data(date_current, type, precision):
    data_to_process = []  #debugging
    delta = datetime.timedelta(minutes=precision)  #debugging
    if type == 'dayh':
        date_previous = date_current - datetime.timedelta(days=1)
        for item in drange(date_previous,
                           date_current + datetime.timedelta(days=1),
                           delta):  #debugging
            data_to_process.append({
                'datetimestamp': num2date(item),
                'Pactiva': 1
            })  #debugging
    elif type == 'week':
        date_previous = (date_current -
                         datetime.timedelta(days=7 + date_current.weekday()))
        for item in drange(date_previous,
                           date_current + datetime.timedelta(days=1),
                           delta):  #debugging
            data_to_process.append({
                'datetimestamp': num2date(item),
                'Pactiva': 1
            })  #debugging
    elif type == 'month':
        if date_current.month < 2:
            date_previous = date_current.replace(year=date_current.year - 1,
                                                 month=12,
                                                 day=1)
        else:
            date_previous = date_current.replace(month=date_current.month - 1,
                                                 day=1)
        for item in drange(date_previous,
                           date_current + datetime.timedelta(days=1),
                           delta):  #debugging
            data_to_process.append({
                'datetimestamp': num2date(item),
                'Pactiva': 1
            })  #debugging
    elif type == 'year':
        date_previous = date_current.replace(year=date_current.year - 1,
                                             month=1,
                                             day=1)
        for item in drange(date_previous,
                           date_current + datetime.timedelta(days=1),
                           delta):  #debugging
            data_to_process.append({
                'datetimestamp': num2date(item),
                'Pactiva': 1
            })  #debugging
    return data_to_process
Beispiel #5
0
def gen_time_seq(date_start_string, tstep, n_tstep, date_string_format = '%Y-%m-%d %H:%M' ) :
    """
    Description.

    Parameters
    ----------
    date_start_string : date from which to start the sequence in string format
                        '%Y-%m-%d %H:%M', e.g. '2015-03-02 12:00'.
    tstep : length of time step in seconds.
    n_tstep : number of time steps
    date_string_format : date string format used in input file, 
                         see https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior
    
    Returns
    -------

    dates_out : list of datetime objects

    Examples
    --------
    # generate a sequence of 20 datetimes instances starting from 2015-03-02 12:00 at 1-minute-interval. 
    >>> dates_out = gen_time_seq(date_start_string = '2015-03-02 12:00' ,tstep = 60 ,n_tstep = 20)

    """
    # convert date_start_string to datetime format
    date_start = dt.datetime.strptime(date_start_string, date_string_format)
    # estimate date_end in datetime format
    date_end = date_start + dt.timedelta(seconds = tstep*n_tstep)
    # generate sequence of dates
    datenums_out = mdates.drange(date_start,date_end - dt.timedelta(seconds=0.001), dt.timedelta(seconds=tstep))
    # convert to list of datetime 
    dates_out = mdates.num2date(datenums_out)

    return(dates_out)
Beispiel #6
0
def print_data(time_series, start_date):
    date_range = mdates.drange(start_date, datetime.date.today(),
                               datetime.timedelta(days=1))

    #plt.plot_date(date_range, usa_data)

    #initial guess for curve fit coefficients
    guess = [300000, 0.1, 50]
    # coefficients and curve fit for curve
    xdata = np.arange(0, len(time_series))
    popt, pcov = curve_fit(logistic_growth, xdata, time_series, p0=guess)

    print(f'Curve fit arguments: {popt}')

    xfuture = np.arange(175)
    ydata = logistic_growth(xdata, *popt)

    # Growth
    plt.plot(xdata, ydata)
    plt.plot(xdata, time_series)

    # derivatives
    plt.plot(xdata[:-1], np.diff(ydata))
    plt.plot(xdata[:-1], np.diff(time_series))

    # predictions
    plt.plot(xfuture, logistic_growth(xfuture, *popt))

    plt.show()
def getFigure_DataAndRevisionData(shop_id, data_from, data_end):
    startDate = datetime.datetime(2015, 6, 1)
    endDate = datetime.datetime(2017, 1, 1)
    delta = datetime.timedelta(days=20)
    dates = drange(startDate, endDate, delta)
    fig = plt.figure(figsize=(15, 8))
    view_ax = fig.add_subplot(1, 1, 1)
    plt.xlabel('date')
    plt.ylabel('view_counts')
    plt.xticks(dates)
    view_ax.set_xticklabels(dates, rotation=45, size=10)
    view_ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
    dataOfShopid = getDataFromStartToEnd(pay_data, shop_id)
    dataReviseOfShopid = getDataFromStartToEnd(pay_revised_data, shop_id)
    view_ax.plot_date(dataOfShopid[0],
                      dataOfShopid[1],
                      'c--',
                      marker='.',
                      linewidth=0.5)
    view_ax.plot_date(dataReviseOfShopid[0],
                      dataReviseOfShopid[1],
                      'r--',
                      marker='.',
                      linewidth=0.5)
    return view_ax
Beispiel #8
0
def render_matplotlib_png(alert_router_id, points, start, end, step):
    """Render a graph PNG based on timeseries data using matplotlib.

    Args:
        alert_router_id: a alert_id-router_gid string
        points: timeseries traffic data points
        start: arrow object representing the start time of the alert
        end: arrow object reprsenting the end time of the alert
        step: the time period each entry in the timeseries data spans
    """
    # every day
    days = DayLocator()
    # every hour
    hours = HourLocator(interval=9)
    delta = datetime.timedelta(seconds=step)
    # calculate x axis points based on step and start time
    dates = drange(start, end, delta)

    # using AGG
    fig = plt.figure(figsize=(10, 6))
    ax = fig.add_subplot(111)
    ax.plot_date(dates, points, '.-')
    ax.grid(True)
    ax.xaxis.set_major_locator(days)
    ax.xaxis.set_minor_locator(hours)
    ax.xaxis.set_major_formatter(DateFormatter('%a'))
    ax.xaxis.set_minor_formatter(DateFormatter('%H:%M'))
    ax.set_xlabel('time')
    ax.set_ylabel('bps')
    ax.set_title('Router Traffic - {}'.format(alert_router_id))
    fig.autofmt_xdate()
    fig.savefig('{}.png'.format(alert_router_id))
Beispiel #9
0
def numPRMerged_graph(df):
    """This function will create a graph for Num of Pr merged"""

    # get oldest and youngest dates from the list
    datelist = df['dates']
    oldest = min(datelist)
    youngest = max(datelist)
    timegap = 12
    dates = mdates.drange(oldest, youngest, timedelta(weeks=timegap))
    # data
    counts = df['counts']
    # Set up the axes and figure
    fig, ax = plt.subplots()
    # (To use the exact code below, you'll need to convert your sequence
    # of datetimes into matplotlib's float-based date format.
    # Use "dates = mdates.date2num(dates)" to convert them.)
    dates = mdates.date2num(dates)
    width = np.diff(dates).min()

    # Make a bar plot. Note that I'm using "dates" directly instead of plotting
    # "counts" against x-values of [0,1,2...]
    ax.bar(datelist, counts.tolist(), align='center', width=width, ec='blue')

    # Tell matplotlib to interpret the x-axis values as dates
    ax.xaxis_date()

    # Make space for and rotate the x-axis tick labels
    fig.autofmt_xdate()
    plt.ylabel('Counts')
    plt.xlabel('Dates')
    plt.title('Number of PRs merged over time')
    plt.savefig('PRmergeRates.png', dpi=400)
    plt.show()
Beispiel #10
0
def locKumulativ(scaleFactor=1, filename="locKumulativ"):
    cursor.execute(
        "SELECT commits.date FROM commits ORDER BY date ASC LIMIT 1")
    firstDate = list(map(lambda x: x[0], cursor.fetchall()))[0]
    firstDate = datetime.fromisoformat(firstDate)
    dates = [firstDate.date()]
    cursor.execute(
        "SELECT commits.date,SUM(modification.loc_variation) from repository JOIN commits ON commits.repository_id == repository.id JOIN modification ON modification.commit_id == commits.id  GROUP BY commits.date"
    )
    dateLocvar = cursor.fetchall()

    dates = list(map(lambda x: datetime.fromisoformat(x[0]), dateLocvar))
    locVar = list(map(lambda x: x[1], dateLocvar))

    sum_dict = {}
    for i in range(len(dates)):
        date = dates[i].date()
        count = locVar[i]
        sum_dict[date] = sum_dict.get(date, 0) + count

    dates = num2date(
        drange(
            min(dates).date(),
            max(dates).date() + timedelta(1), timedelta(1)))
    sums = numpy.asarray(
        [sum_dict.get(d.date(), 0) / scaleFactor for d in dates]).cumsum()

    plt.step(dates, sums, alpha=1, label="LOC", linewidth=2)
    plt.grid(True)
    plt.xlabel('Zeit', fontsize=16)
    plt.ylabel('Lambdas / LOC', fontsize=16)
    plt.legend(title='Legende')
    plt.savefig("plots/3-data/" + filename + ".png", dpi=500, pad_inches=0)
Beispiel #11
0
def plot_accum(serie,
               data,
               real_data=True,
               ax=None,
               label="Modelo",
               blur=1.0,
               cor_serie="C0",
               cor_dados='C1x-',
               eng_fmt=True,
               legend=True,
               cut_day=None,
               loc=1):
    n_pts = len(serie)
    start = dt.datetime.strptime("29-03-2020", "%d-%m-%Y")
    then = start + dt.timedelta(days=n_pts)
    days = mdates.drange(start, then, dt.timedelta(days=1))
    if ax == None:
        ax = plt.gca()
    ax.plot(days, serie, cor_serie, label=label, alpha=blur)
    if cut_day != None:
        new_cut_day = start + dt.timedelta(days=cut_day)
        ax.axvline(x=new_cut_day, color="grey", linestyle="--")
    if real_data:
        ax.plot(days, data, cor_dados, label="Dados")
    ax.grid()
    ax.set_xlabel("Dias")
    if eng_fmt:
        ax.yaxis.set_major_formatter(EngFormatter())
    if legend:
        ax.legend(loc=loc)

    ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m"))
    return
Beispiel #12
0
def rise_set2():
    fig, ax = plt.subplots()
    x = np.linspace(0, 366, 366)
    y = 12 - azimuth(lat*torad, asin(sin(D*torad)*sin(w*x*torad)))/15
    z = 12 + azimuth(lat*torad, asin(sin(D*torad)*sin(w*x*torad)))/15
    
    now = dt.datetime.now()
    equinox = datetime(2020,3,20)
    then = equinox + dt.timedelta(days=366)
    days = mdates.drange(equinox,then,dt.timedelta(days=1))
    #ax.text(0.0, 0.2, "Date", transform=ax.transAxes, 
    #        fontsize=14, fontname='Monospace', color='tab:blue')
    plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%y'))     #('%Y-%m-%d'))
    plt.gca().xaxis.set_major_locator(mdates.DayLocator(interval=15))
    plt.plot(days,y, label='rise')
    plt.plot(days,z, label='set')
    #color = 'tab:blue'
    ax.set_ylabel('time (h)', fontsize=12, fontname='Monospace', color='tab:blue')
    ax.set_xlabel('Date', fontsize=12, fontname='Monospace', color='tab:blue')
    plt.legend()
    plt.gcf().autofmt_xdate()
    
    
    #ax.plot(x,y)
    #ax.plot(x,z)
    plt.title('Rise and set time')
    #ax.set_ylim(-25,25)
    plt.grid()
    #plt.axis("equal")
    plt.show()
Beispiel #13
0
def set_df(df,
           dt_start,
           dt_fim,
           municipios='all',
           skip=False,
           header=['Data', 'Municipio', 'Casos']):
    if municipios == 'all':
        municipios = set(df['Municipio'])
    else:
        if skip == True:
            municipios = set(
                df[~df['Municipio'].str.contains('|'.join(municipios))]
                ['Municipio'])
        else:
            municipios = set(df[df['Municipio'].str.contains(
                '|'.join(municipios))]['Municipio'])

    ## Configurando os dias
    dt_start = dt.datetime.strptime(dt_start, '%d-%m-%Y')
    dt_fim = dt.datetime.strptime(dt_fim, '%d-%m-%Y')
    days = mdates.drange(dt_start, dt_fim, dt.timedelta(days=1))

    dt_start = dt.datetime.strftime(dt_start, '%d-%m-%Y')
    dt_fim = dt.datetime.strftime(dt_fim, '%d-%m-%Y')
    dates = [
        dt.datetime.strftime(mdates.num2date(i), '%d-%m-%Y').replace('-', '/')
        for i in days
    ]

    ## Extraindo os dados e organizando em listas para o Dicionario
    casos = []
    nome_m = []
    data_m = []
    for m in municipios:
        lst = []
        lst_m = [m] * len(dates)
        lst_d = []
        for d in dates:
            df = df[df['Municipio'] == m]
            lst.append(len(df[df['Data'] == d]))
            lst_d.append(d)
        nome_m.append(lst_m)
        casos.append(lst)
        data_m.append(lst_d)

    ## Criando o Dicionario
    lst = [[], [], []]
    for c, m, d in zip(casos, nome_m, data_m):
        lst[0] += d
        lst[1] += m
        lst[2] += c

    dic = {}
    for i, h in enumerate(header):
        dic.update({h: lst[i]})

    ## Transformando o dicionario em DataFrame
    df = pd.DataFrame(dic)

    return df
Beispiel #14
0
    def initPlot(self):
        """ redraw the canvas to set the initial x and y axes when plotting starts """

        self.starttime = datetime.datetime.today()
        self.currenttime = self.starttime + datetime.timedelta(seconds=3)
        self.endtime = self.starttime + datetime.timedelta(seconds=15)
        self.timeaxis = num2date(drange(self.starttime, self.endtime, datetime.timedelta(milliseconds=10)))

        self.xvalues.append(self.timeaxis[0])
        self.yvalues.append(self.parentPanel.myECG.ecg_leadII[0])

        # for counter purposes only
        self.ybuffer = self.yvalues

        self.lines[0].set_data(self.xvalues, self.yvalues)

        self.axes.set_xlim((date2num(self.starttime), date2num(self.currenttime)))
        self.axes.xaxis.set_ticklabels(
            self.createXTickLabels(self.currenttime), rotation=30, ha="right", size="smaller", name="Calibri"
        )

        self.samples_counter += 1
        self.ysamples_counter += 1

        self.buff_counter = 1
Beispiel #15
0
def generate_graph():
	date1 = datetime.datetime( 2000, 3, 2)
	date2 = datetime.datetime( 2000, 3, 6)
	delta = datetime.timedelta(hours=6)
	dates = drange(date1, date2, delta)
	
	y = arange( len(dates)*1.0)

	fig, ax = pyplot.subplots()
	ax.plot_date(dates, y*y)

	ax.set_xlim( dates[0], dates[-1] )

	ax.xaxis.set_major_locator( DayLocator() )
	ax.xaxis.set_minor_locator( HourLocator(arange(0,25,6)) )
	ax.xaxis.set_major_formatter( DateFormatter('%Y-%m-%d') )

	ax.fmt_xdata = DateFormatter('%Y-%m-%d %H:%M:%S')
	fig.autofmt_xdate()

	file_name = str(generate_uuid()) + '.png'
	complete_file_name = GRAPHS_FOLDER + '/' + file_name
	logger.debug ("Generando grafico: " + file_name)
	pyplot.savefig( complete_file_name )
	#pyplot.show()

	return [file_name,complete_file_name]
Beispiel #16
0
def reposPTime(filename="reposPTime"):
    cursor.execute("SELECT commits.date from commits")
    commitDates = cursor.fetchall()
    commitDates = list(map(lambda x: datetime.fromisoformat(x[0]),
                           commitDates))
    cursor.execute("SELECT repository.creation from repository")
    repoDates = cursor.fetchall()
    repoDates = list(
        map(lambda x: datetime.fromisoformat(x[0]).date(), repoDates))

    dates = num2date(
        drange(
            min(commitDates).date(),
            max(commitDates).date() + timedelta(1), timedelta(1)))

    repo_dict = {}
    for i in range(len(dates)):
        date = dates[i].date()

        repo_dict[date] = len(list(filter(lambda x: x < date, repoDates)))

    repos = numpy.asarray([repo_dict.get(d.date(), 0) for d in dates])

    plt.step(dates, repos, label="Anzahl Repositories")
    plt.legend(title='Anzahl Repositories',
               bbox_to_anchor=(0.05, 0.95),
               loc=2,
               borderaxespad=0.)
    plt.savefig("plots/3-data/" + filename + ".png", dpi=300)
def get_time_info(nc_file, current_utc_hour, tz_info):
    """ Retrieves time frame of plots starting at the current UTC hour and ending 3 days after the current hour. 

    Parameters
    ----------
    nc_file : object
        The netCDF dataset that provides the start time of data.
    current_utc_hour : float
        The current UTC hour.

    Returns
    -------
    dates : list
        A list of Gregorian ordinals (floats) from the current UTC time to 3 days later
    """

    #init_time = nc_file.variables["forc_time"][:][0]
    init_time = nc_file.variables["forc_time"][:]
    #print "init_time: ", init_time
    init_time = init_time + current_utc_hour * 3600
    #begin_time = datetime.datetime.fromtimestamp(init_time, tz=tz_info)
    #end_time = datetime.datetime.fromtimestamp(init_time + (3*24*3600), tz=tz_info) # only plot 3 days
    begin_time = datetime.datetime.fromtimestamp(init_time)
    end_time = datetime.datetime.fromtimestamp(init_time + (3*24*3600)) # only plot 3 days
    #print "tz_info: ", tz_info
    #print "begin_time: ", begin_time
    #print "end_time: ", end_time
    delta = datetime.timedelta(hours=1) # Move time interval before all var arrays are set
    dates = drange(begin_time, end_time, delta)
    return dates
Beispiel #18
0
def draw():
    from matplotlib.dates import DayLocator, HourLocator,MonthLocator ,WeekdayLocator, DateFormatter, drange
    from matplotlib.dates import MONDAY
    import datetime

    mondays   = WeekdayLocator()
    days = DayLocator(None, 3)
    months    = MonthLocator()
    yList = [0]*55

    yList[0] = 0.11; yList[1] = 0.109; yList[2] = 0.108;yList[3] = 0.11; yList[4] = 0.111; yList[5] = 0.109; yList[6] = 0.111; yList[7] = 0.109; yList[8] = 0.108; yList[9] = 0.111; yList[10] = 0.112
    figure, axes = plt.subplots()
    startDate = datetime.datetime(2014, 3, 6, 0, 0, 0)
    endDate = datetime.datetime(2014, 4, 30, 0, 0, 0)
    delta = datetime.timedelta(hours=24)
    dates = drange(startDate , endDate, delta)
    axes.plot_date(dates,  yList,  '-',  marker='.',  linewidth=1)
    axes.xaxis.set_major_locator(days)
    axes.xaxis.set_major_formatter( DateFormatter("%b '%d"))
    axes.xaxis.set_minor_locator(mondays)
    axes.fmt_xdata = DateFormatter("%b '%d")
    plt.ylim(0.08,0.20)
    plt.ylabel('播放率')

    axes.autoscale_view()
    axes.xaxis.grid(True, 'major')
    axes.xaxis.grid(True, 'minor')
    axes.grid(True)
    figure.autofmt_xdate()
    plt.show()
Beispiel #19
0
    def run(self):
        """ start ECG plotting """

        while not self.stopPlotThread.isSet():

            self.parentFrame.ecgplotter.plot()
            # check if the thread has been stopped. if yes, no need to update endtime.
            if not self.stopPlotThread.isSet():
                self.parentFrame.ecgplotter.endtime += datetime.timedelta(seconds=15)
                # initialize the time size (nagiiba kase after every 15 seconds. needs to be extended
                self.parentFrame.ecgplotter.timeaxis = num2date(
                    drange(
                        self.parentFrame.ecgplotter.starttime,
                        self.parentFrame.ecgplotter.endtime,
                        datetime.timedelta(milliseconds=10),
                    )
                )

            else:
                break

        # add slider at the end of plotting only
        self.parentFrame.ecgplotter.addSlider(self.parentFrame.ecgplotter.endtime)
        self.parentFrame.ecgplotter.canvas.draw()
        self.parentFrame.ecgplotter.gui_repaint()
Beispiel #20
0
def plot_peaks_lockdown(dictagg,
                        verzia_modelu,
                        scen_vyber,
                        legenda_vsetky_scenare,
                        title,
                        total_days,
                        day_zero=dt.datetime.now() - dt.timedelta(days=0),
                        SEIR=True):
    end = day_zero + dt.timedelta(days=total_days + 1)
    days = mdates.drange(day_zero, end, dt.timedelta(days=1))
    months = mdates.MonthLocator()
    sns.set(rc={'figure.figsize': (11, 4)})

    legenda = [legenda_vsetky_scenare[scen] for scen in scen_vyber]

    fig, ax = plt.subplots()
    clrs = ['red', 'purple', 'teal', 'blue', 'green', 'yellow', 'orange']

    linest = '-'
    with sns.axes_style("darkgrid"):
        for scen in scen_vyber:
            if scen > 0:
                linest = '--'
            scenar = 'SIR_scenar' + str(scen)
            means = dictagg[scenar].inf
            p5 = dictagg[scenar].inf5
            p95 = dictagg[scenar].inf95

            if SEIR == True:
                means = means + dictagg[scenar].exp
                p5 = p5 + dictagg[scenar].exp5
                p95 = p95 + dictagg[scenar].exp95

            ax.plot(days, means, c=clrs[scen], linestyle=linest)
            ax.fill_between(days, p5, p95, alpha=0.3, facecolor=clrs[scen])
            ax.xaxis.set_major_locator(months)
            ax.xaxis.set_major_formatter(mdates.DateFormatter('%b' '%y'))
    plt.xticks(rotation=45)
    plt.title(title)
    plt.ylabel('Pomer nakazených')
    plt.legend(legenda)
    plt.tight_layout()
    plt.axvline(x=day_zero + dt.timedelta(days=42),
                label='Lockdown 6 týždňov',
                color='purple')
    plt.axvline(x=day_zero + dt.timedelta(days=21),
                label='Lockdown 3 týždne',
                color='orange')

    path = './plots/' + str(verzia_modelu) + '.png'
    plt.savefig(path, dpi=300)
    plt.close

    i = 0
    for scen in scen_vyber:
        scenar = 'SIR_scenar' + str(scen)
        print('Scenar:', legenda[i], ', Peak:',
              np.round(np.max(dictagg[scenar].inf) * 100, 2), '%, Day: ',
              dictagg[scenar].inf.idxmax())
        i += 1
Beispiel #21
0
def plot_samples(sc, basedir, idx=None):
    res = 15
    t_day_start = sc.t_block_start - timedelta(hours=sc.t_block_start.hour,
                                               minutes=sc.t_block_start.minute)
    skip = (t_day_start - sc.t_start).total_seconds() / 60 / res
    i_block_start = (sc.t_block_start - t_day_start).total_seconds() / 60 / res
    i_block_end = (sc.t_block_end - t_day_start).total_seconds() / 60 / res
    t = drange(sc.t_block_start, sc.t_block_end, timedelta(minutes=res))

    unctrl = load(p(basedir, sc.run_unctrl_datafile))
    P_el_unctrl = unctrl[:, 0, skip + i_block_start:skip + i_block_end].sum(0)

    sample_data = load(p(basedir, sc.run_pre_samplesfile))
    if idx is not None:
        sample_data = sample_data[idx].reshape((1, ) + sample_data.shape[1:])
    fig, ax = plt.subplots(len(sample_data))
    if len(sample_data) == 1:
        ax = [ax]
    for i, samples in enumerate(sample_data):
        # t = np.arange(samples.shape[-1])
        # ax[i].plot(t, P_el_unctrl, ls=':')
        l_unctrl, = ax[i].plot_date(t,
                                    P_el_unctrl,
                                    fmt=':',
                                    color=PRIMB,
                                    drawstyle='steps-post',
                                    lw=0.75)
        l_unctrl.set_dashes([1.0, 1.0])
        for s in samples:
            ax[i].plot_date(t, s, fmt='-', drawstyle='steps-post', lw=0.75)
    fig.autofmt_xdate()
Beispiel #22
0
def plot_slp(sc, bd):
    slp = _read_slp(sc, bd)

    res = 1
    if (sc.t_end - sc.t_start).total_seconds() / 60 == slp.shape[-1] * 15:
        res = 15
    t = drange(sc.t_start, sc.t_end, timedelta(minutes=res))

    fig, ax = plt.subplots()
    ax.set_ylabel('P$_{el}$ [kW]')
    ymax = max(slp.max(), slp.max())
    ymin = min(slp.min(), slp.min())
    ax.set_ylim(ymin - (ymin * 0.1), ymax + (ymax * 0.1))
    ax.plot_date(t, slp, fmt='-', lw=1, label='H0')
    leg0 = ax.legend(bbox_to_anchor=(0., 1.02, 1., .102),
                     loc=3,
                     ncol=4,
                     borderaxespad=0.0,
                     fancybox=False)

    fig.autofmt_xdate()
    for label in leg0.get_texts():
        label.set_fontsize('x-small')
    fig.subplots_adjust(left=0.1, right=0.95, top=0.88, bottom=0.2)

    return fig
Beispiel #23
0
def plot_samples(sc, basedir, idx=None):
    res = 15
    t_day_start = sc.t_block_start - timedelta(hours=sc.t_block_start.hour,
                                               minutes=sc.t_block_start.minute)
    skip = (t_day_start - sc.t_start).total_seconds() / 60 / res
    i_block_start = (sc.t_block_start - t_day_start).total_seconds() / 60 / res
    i_block_end = (sc.t_block_end - t_day_start).total_seconds() / 60 / res
    t = drange(sc.t_block_start, sc.t_block_end, timedelta(minutes=res))

    unctrl = load(p(basedir, sc.run_unctrl_datafile))
    P_el_unctrl = unctrl[:,0,skip + i_block_start:skip + i_block_end].sum(0)

    sample_data = load(p(basedir, sc.run_pre_samplesfile))
    if idx is not None:
        sample_data = sample_data[idx].reshape((1,) + sample_data.shape[1:])
    fig, ax = plt.subplots(len(sample_data))
    if len(sample_data) == 1:
        ax = [ax]
    for i, samples in enumerate(sample_data):
        # t = np.arange(samples.shape[-1])
        # ax[i].plot(t, P_el_unctrl, ls=':')
        l_unctrl, = ax[i].plot_date(t, P_el_unctrl, fmt=':', color=PRIMB, drawstyle='steps-post', lw=0.75)
        l_unctrl.set_dashes([1.0, 1.0])
        for s in samples:
            ax[i].plot_date(t, s, fmt='-', drawstyle='steps-post', lw=0.75)
    fig.autofmt_xdate()
Beispiel #24
0
def draw(item, maxy, ylabel, filename_fig):
    array = np.zeros((plot_resolution_x, plot_resolution_y))
    # x1 = np.arange(max_x * 1000)/1000
    for detections in item:
        x1, y1 = zip(*detections)
        # p = np.poly1d(coeffs)
        # y1 = np.exp(p(x1))
        zer = np.zeros_like(array)
        prev_point = None
        for x_elem, y_elem in zip(x1, y1):
            if y_elem >= maxy:
                continue
            if x_elem >= max_x:
                continue
            x_p = x_to_xid(x_elem, max_x, plot_resolution_x)
            y_p = y_to_yid(y_elem, maxy, plot_resolution_y)
            if prev_point is None:
                zer[x_p, y_p] = 1.0
            else:
                zer[prev_point[0]:(x_p + 1), prev_point[1]:(y_p + 1)] = 1.0
            prev_point = (x_p, y_p)
        array += zer
    fig, ax = plt.subplots(figsize=(10, 6))
    # s = ndimage.generate_binary_structure(2, 1)
    # array = ndimage.grey_dilation(array, footprint=s)
    pa = ax.imshow(np.rot90(array),
                   cmap='BuPu',
                   vmin=0,
                   vmax=np.maximum(5, np.percentile(array, 99)),
                   aspect='auto')
    ax.set_title(f'q={q_id}, ({bundle_prefix.strip("_")})', fontsize=18)
    cbb = plt.colorbar(pa, shrink=0.35)
    cbarlabel = 'Zagęszczenie trajektorii'
    cbb.ax.set_ylabel(cbarlabel, rotation=-90, va="bottom", fontsize=18)

    ax.set_xticks(
        np.arange(0, plot_resolution_x + 1, 7 * plot_resolution_x / max_x))
    now = parser.parse(begin_date)
    then = now + dt.timedelta(days=max_x + 1)
    days = mdates.drange(now, then, dt.timedelta(days=7))
    t = [
        dt.datetime.fromordinal(int(day)).strftime('%d/%m/%y') for day in days
    ]
    ax.set_xticklabels([t[i] for i, v in enumerate(range(0, max_x + 1, 7))],
                       rotation=30)
    ax.set_yticks([
        v for v in np.arange(plot_resolution_y, -1, -plot_resolution_y / 10.0)
    ])
    ax.set_yticklabels([int(v) for v in np.arange(0, maxy + 1, maxy / 10.0)
                        ])  # , list(np.arange(20)))

    ax.set_ylabel(ylabel, fontsize=18)
    xlabel_pl = 'Data'
    xlabel_en = 'Days from today'
    xlabel = xlabel_pl
    ax.set_xlabel(xlabel, fontsize=18, labelpad=16)
    plt.tight_layout()
    plt.savefig(os.path.join(d, filename_fig), dpi=300)
    plt.close(fig)
Beispiel #25
0
 def test_drange(self):
     temp = self.temp
     temp = temp.split(" ")
     x = datetime.datetime(int(temp[0]), int(temp[1]), int(temp[2]))
     y = datetime.datetime(int(temp[3]), int(temp[4]), int(temp[5]))
     delta = datetime.timedelta(hours=5)
     self.assertEqual(
         dates.drange(x, y, delta)[5], float(self.expectedValue))
Beispiel #26
0
def hist_date(date_vector, lim_inf, lim_sup, dt=1):  # Default = 1day bin
    '''
  Create the bin of a datetime vector.
  Input:
  @date_vector : array of dates in DATETIME format (length = N)
  @lim_inf : min of the hist x-range, in DATETIME format (e.g., min(date_vector))
  @lim_sup : max of the hist x-range, in DATETIME format (e.g., max(date_vector))
  @dt : sampling interval (default = 1 day)
  
  Output:
  @bins4hist : array of date values (in float) for the histogram, with the latest values being lim_sup + 1 dt (length = N+1)
  @bins4plot : array of date values (in float) for the bar plot (length = N)
  @cnts : counts in each bins4hist (length = N)
  '''

    delta = datetime.timedelta(days=dt)  # Bins of 24hrs

    #Convert the limits in order to start from 00:00:00 of the first day and finish on 23:59:59 of the last day
    lim_inf = float(int(matplotlib.dates.date2num(lim_inf)))
    lim_sup = math.ceil(matplotlib.dates.date2num(lim_sup))

    #Convert datetime dates into floats
    date_vector_num = map(
        lambda x: matplotlib.dates.date2num(x),
        date_vector)  # == date_num = matplotlib.dates.date2num(date_good)

    #Ned to re-convert into datetime format for the drange()
    lim_inf = matplotlib.dates.num2date(lim_inf)
    lim_sup = matplotlib.dates.num2date(lim_sup)

    #Create the array bins4plot with equally spaced dates, with step = dt
    #bins4plots contains N points, from lim_inf -> lim_sup
    bins4plot = drange(lim_inf, lim_sup, delta)

    #bins4hist contains N+1 points, from lim_inf -> lim_sup + 1 dt
    bins4hist = drange(lim_inf, lim_sup + datetime.timedelta(days=dt), delta)

    #Counts in each bins4hist
    cnts = np.histogram(date_vector_num, bins=bins4hist)[0]

    #date_vector_num = [matplotlib.dates.date2num(item) for item in date_vector] # Convert type(datetime) -> number
    #cnts = np.histogram(date_vector_num, bins = dt_limits)[0] # Counts for each dt, with width = delta

    #bins4hist = [0.5*(dt_limits[i] + dt_limits[i+1]) for i in range(len(dt_limits)-1)] # Re-compute the center of each bin in order to have same size counts and dt_i

    return bins4hist, bins4plot, cnts
Beispiel #27
0
def plot_data(epidemics_start_date, confirmed_cases, recovered_cases,
    death_cases, daily_tests=None, paper_config=False):
    """Plot the time series epidemiological statistics.
    
    Parameters
    ----------
    epidemics_start_date : datetime.datetime
        First day of the epidemics.
    confirmed_cases : numpy.ndarray
        Cumulative number of confirmed positive infected cases.
    recovered_cases : numpy.ndarray
        Cumulative number of confirmed recoveries.
    death_cases : numpy.ndarray
        Cumulative number of confirmed deaths.
    daily_tests : numpy.ndarray, optional
        Time series of daily performed tests.
    paper_config : bool, optional
        Activate LaTeX mode.
    """
    removed_cases = recovered_cases + death_cases
    active_cases = confirmed_cases - removed_cases
    epidemics_end_date = epidemics_start_date \
                         + dt.timedelta(confirmed_cases.size)
    days = mdates.drange(
        epidemics_start_date, epidemics_end_date, dt.timedelta(days=1))
    if paper_config:
        configure_paper()
        fig = plt.figure(figsize=(9, 5))
    else:
        mpl.rcParams.update(mpl.rcParamsDefault)
        fig = plt.figure(figsize=(9, 5))
    axs = fig.subplots(nrows=2, ncols=2, sharex=True, squeeze=True)
    axs[0,0].plot(days, confirmed_cases, '.-', c='b',
        label='Total confirmed cases')
    axs[0,0].plot(days, recovered_cases, '.--', c='r',
        label='Total recovered cases')
    axs[0,0].legend()
    axs[0,0].grid()
    axs[0,0].set_ylabel('$N$')
    axs[1,0].plot(days, death_cases, '.-', c='b', label='Death cases')
    axs[1,0].legend()
    axs[1,0].grid()
    axs[1,0].set_ylabel('$N$')
    axs[0,1].plot(days, active_cases, '.-', c='b',
        label='Current active cases')
    axs[0,1].legend()
    axs[0,1].grid()
    axs[0,1].set_ylabel('$N$')
    if daily_tests is not None:
        axs[1,1].plot(days, daily_tests, '.-', c='b', label='Tests performed')
        axs[1,1].legend()
        axs[1,1].grid()
        axs[1,1].set_ylabel('$N$')
    _ = fig.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
    _ = fig.gca().xaxis.set_major_locator(mdates.DayLocator(interval=20))
    _ = plt.gcf().autofmt_xdate()
    plt.tight_layout()
    plt.show()
Beispiel #28
0
Datei: nem.py Projekt: bje-/NEMO
def plot(context, spills=False, filename=None, showlegend=True):
    """Produce a pretty plot of supply and demand."""
    spill = context.spill
    # aggregate demand
    demand = context.demand.sum(axis=0)

    plt.ylabel('Power (MW)')
    title = 'Supply/demand balance\nRegions: %s' % context.regions
    plt.suptitle(title)

    if showlegend:
        _legend(context)
    xdata = mdates.drange(context.startdate,
                          context.startdate + dt.timedelta(hours=context.hours),
                          dt.timedelta(hours=1))

    # Plot demand first.
    plt.plot(xdata, demand, color='black', linewidth=2)
    if spills:
        peakdemand = np.empty_like(demand)
        peakdemand.fill(demand.max())
        plt.plot(xdata, peakdemand, color='black', linestyle='dashed')

    accum = np.zeros(context.timesteps)
    prev = accum.copy()
    for g in _generator_list(context):
        idx = context.generators.index(g)
        accum += context.generation[idx]
        # Ensure total generation does not exceed demand in any timestep.
        assert(np.round(accum, 6) > np.round(demand, 6)).sum() == 0
        plt.plot(xdata, accum, color='black', linewidth=0.5)
        plt.fill_between(xdata, prev, accum, facecolor=g.patch.get_fc())
        prev = accum.copy()
    # Unmet demand is shaded red.
    plt.fill_between(xdata, accum, demand, facecolor='red')

    if spills:
        prev = demand.copy()
        for g in [g for g in context.generators if g.region() in context.regions]:
            idx = context.generators.index(g)
            accum += spill[idx]
            plt.plot(xdata, accum, color='black')
            plt.fill_between(xdata, prev, accum, facecolor=g.patch.get_fc(), alpha=0.3)
            prev = accum.copy()

    plt.gca().xaxis_date()
    plt.gcf().autofmt_xdate()

    for hr in np.argwhere(context.unserved):
        unserved_dt = context.startdate + dt.timedelta(hours=hr[0])
        xvalue = mdates.date2num(unserved_dt)
        _, ymax = plt.gca().get_ylim()
        plt.plot([xvalue], [ymax - 200], "yv", markersize=15, color='red')

    if not filename:
        plt.show()  # pragma: no cover
    else:
        plt.savefig(filename)
def simulate(epidemics_start_date,
             confirmed_cases,
             averaging_period=16,
             symptoms_delay=3):
    """Simulate and visualize the R0 with respect to the number of 
    confirmed infections daily."
    
    Parameters
    ----------
    epidemics_start_date : datetime.datetime
    confirmed_cases : numpy.ndarray
        The total number of confirmed infected COVID-19 cases per day.
    averaging_period : int, optional
        Parameter for smoothing the `confirmed_cases` array.
    symptoms_delay : int, optional
        Number of days between the infection and the confirmation
        (incubation period estimate).
    """
    delay = averaging_period + symptoms_delay

    R = _estimate(confirmed_cases, averaging_period, symptoms_delay)
    R_averaging_period = int(averaging_period / symptoms_delay)
    R_smoothed = moving_average(R, R_averaging_period)

    epidemics_duration = confirmed_cases.size
    dates = mdates.drange(
        epidemics_start_date,
        epidemics_start_date + dt.timedelta(days=epidemics_duration),
        dt.timedelta(days=1))
    fig = plt.figure(figsize=(12, 6))
    ax1 = fig.add_subplot(111)
    ax1.plot(dates, confirmed_cases, 'b-', label='Cumalitive cases')
    ax1.tick_params(axis='y', labelcolor='b')
    ax1.set_ylabel('Confirmed cases', color='b')
    ax1.legend()
    ax1.grid(None)

    ax2 = ax1.twinx()
    ax2.scatter(dates[:-delay + 1],
                R,
                color='r',
                edgecolor='black',
                label='R values')
    ax2.plot(dates, np.ones(dates.shape), 'k--', label='Critical value')
    ax2.plot(dates[R_averaging_period:-delay + 2],
             R_smoothed,
             'r-',
             linewidth=2,
             label='R averaged')
    ax2.tick_params(labelcolor='r')
    ax2.set_ylabel('R values', color='r')
    ax2.legend()

    fig.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
    fig.gca().xaxis.set_major_locator(mdates.DayLocator(interval=10))
    fig.autofmt_xdate()
    plt.show()
Beispiel #30
0
def print_plot_for_dollar_euro_x_days(days):
    dollar = get_currency_rates_from_x_last_days('usd', days)
    euro = get_currency_rates_from_x_last_days('eur', days)
    # for example dollar[0] has rates, dollar[1] has dates
    if len(dollar[0]) > 0:
        x__days_ago_date = (datetime.strptime(dollar[1][0], "%Y-%m-%d")).date()
        today_date = (datetime.strptime(euro[1][len(euro[1]) - 1], "%Y-%m-%d") + timedelta(days=1)).date()
        dates = drange(x__days_ago_date, today_date, timedelta(days=1))
        print_plot_for_currencies(dollar[0], euro[0], dates)
Beispiel #31
0
def plot_aggregated(sc, bd, unctrl, ctrl, ctrl_sched, res=1):
    t_day_start = sc.t_block_start - timedelta(hours=sc.t_block_start.hour,
                                         minutes=sc.t_block_start.minute)
    t = drange(t_day_start, sc.t_end, timedelta(minutes=res))
    skip = (t_day_start - sc.t_start).total_seconds() / 60 / res
    i_block_start = (sc.t_block_start - t_day_start).total_seconds() / 60 / res
    i_block_end = (sc.t_block_end - t_day_start).total_seconds() / 60 / res

    P_el_unctrl = unctrl[:,0,skip:].sum(0)
    P_el_ctrl = ctrl[:,0,skip:].sum(0)
    P_el_sched = ctrl_sched[:,skip:].sum(0)

    T_storage_ctrl = ctrl[:,2,skip:]

    ft = np.array([t[0]] + list(np.repeat(t[1:-1], 2)) + [t[-1]])
    P_el_ctrl_fill = np.repeat(P_el_ctrl[:-1], 2)

    fig, ax = plt.subplots(2, sharex=True)
    fig.subplots_adjust(left=0.11, right=0.95, hspace=0.3, top=0.98, bottom=0.2)
    ax[0].set_ylabel('P$_{\mathrm{el}}$ [kW]')
    ymax = max(P_el_unctrl.max(), P_el_ctrl_fill.max(), P_el_sched.max(), 0) / 1000.0
    ymin = min(P_el_unctrl.min(), P_el_ctrl_fill.min(), P_el_sched.min(), 0) / 1000.0
    ax[0].set_ylim(ymin - abs(ymin * 0.1), ymax + abs(ymax * 0.1))
    # xspace = (t[-1] - t[-2])
    ax[0].set_xlim(t[0], t[24])
    ax[0].axvspan(t[i_block_start], t[i_block_end], fc=GRAY+(0.1,), ec=EC)
    ax[0].axvline(t[0], ls='-', color=GRAY, lw=0.5)
    ax[0].axvline(t[len(t)/2], ls='-', color=GRAY, lw=0.5)
    l_unctrl, = ax[0].plot_date(t, P_el_unctrl / 1000.0, fmt=':', color=PRIMB, drawstyle='steps-post', lw=0.75)
    l_unctrl.set_dashes([1.0, 1.0])
    # add lw=0.0 due to bug in mpl (will show as hairline in pdf though...)
    l_ctrl = ax[0].fill_between(ft, P_el_ctrl_fill / 1000.0, facecolors=PRIM+(0.5,), edgecolors=EC, lw=0.0)
    # Create proxy artist as l_ctrl legend handle
    l_ctrl_proxy = Rectangle((0, 0), 1, 1, fc=PRIM, ec=WHITE, lw=0.0, alpha=0.5)
    l_sched, = ax[0].plot_date(t, P_el_sched / 1000.0, fmt='-', color=PRIM, drawstyle='steps-post', lw=0.75)

    ymax = T_storage_ctrl.max() - 273
    ymin = T_storage_ctrl.min() - 273
    ax[1].set_ylim(ymin - abs(ymin * 0.01), ymax + abs(ymax * 0.01))
    ax[1].set_ylabel('T$_{\mathrm{storage}}\;[^{\circ}\mathrm{C}]$', labelpad=9)
    ax[1].axvspan(t[i_block_start], t[i_block_end], fc=GRAY+(0.1,), ec=EC)
    ax[1].axvline(t[0], ls='-', color=GRAY, lw=0.5)
    ax[1].axvline(t[len(t)/2], ls='-', color=GRAY, lw=0.5)
    for v in T_storage_ctrl:
        ax[1].plot_date(t, v - 273.0, fmt='-', color=PRIMA, alpha=0.25, lw=0.5)
    l_T_med, = ax[1].plot_date(t, T_storage_ctrl.mean(0) - 273.0, fmt='-', color=PRIMA, alpha=0.75, lw=1.5)

    ax[0].xaxis.get_major_formatter().scaled[1/24.] = '%H:%M'
    ax[-1].set_xlabel('Time')
    fig.autofmt_xdate()
    ax[1].legend([l_sched, l_unctrl, l_ctrl_proxy, l_T_med],
                 ['Schedule', 'Uncontrolled', 'Controlled', 'Storage temperatures'],
                 bbox_to_anchor=(0., 1.03, 1., .103), loc=8, ncol=4,
                 handletextpad=0.2, mode='expand', handlelength=3,
                 borderaxespad=0.25, fancybox=False, fontsize='x-small')

    return fig
def Draw_Figure(pay_data,all_view_data,shop_id):
   shop_path = 'data/shop_info.txt'
   '''读取shop_info data'''
   shop_info = pd.read_csv(shop_path,
                           names=['shopid', 'city_name', 'location_id', 'per_pay', 'score', 'comment_cnt', 'shop_level',
                                  'cate1_name', 'cate2_name', 'cate3_name'])

   startDate = datetime.datetime(2015, 6, 1)
   endDate = datetime.datetime(2017, 1, 1)
   delta = datetime.timedelta(days=20)
   dates = drange(startDate, endDate, delta) #获取date刻度List
   fig = plt.figure(figsize=(15, 8))
   view_ax = fig.add_subplot(1, 1, 1)
   view_ax.set_xticklabels(dates, rotation=45, size=5)
   _cur_shop_info = shop_info[shop_info.shopid == shop_id ]
   if str(_cur_shop_info.cate1_name.values[0]) == '美食':
      figure_pay_path = 'M1_Figure\\';
   else:
      figure_pay_path = 'CS1_Figure\\';
   plt.title('\nshopID:'+str(_cur_shop_info.shopid.values[0])+' city:'+str(_cur_shop_info.city_name.values[0])
             +' perpay:'+str(_cur_shop_info.per_pay.values[0])+'\nscore:'+str(_cur_shop_info.score.values[0])+' conmment:'+
             str(_cur_shop_info.comment_cnt.values[0])+' cate1_name:'+str(_cur_shop_info.cate1_name.values[0])+'\ncate2_name:'+
             str(_cur_shop_info.cate2_name.values[0])+'cate3_name'+str(_cur_shop_info.cate3_name.values[0]))
   ##################绘制view_time折线图#############################################################################################

   _cur_date_series = all_view_data[all_view_data.shopid == shop_id]['time'].tolist()
   _cur_count_series = all_view_data[all_view_data.shopid == shop_id]['count'].tolist()
   _cd_series = pd.Series(_cur_count_series, index=_cur_date_series)
   if len(_cd_series.index)!=0:
      view_index = pd.DatetimeIndex([_cd_series.index[0], _cd_series.index[len(_cd_series)-1]])
   else:
      view_index = pd.DatetimeIndex(['2016-7-1', '2016-10-31'])

   _view_series = pd.Series([0, 0], index=view_index).resample('D', ).pad()
   for time in _cd_series.index:
      _view_series[time] = _cd_series[time]
   view_cur_date_series = _view_series.index
   view_cur_count_series =_view_series.values
###########################绘制pay_time折线图###########################################################################
   _cur_date_series = pay_data[pay_data.shopid == shop_id]['time'].tolist()
   _cur_count_series = pay_data[pay_data.shopid == shop_id]['count'].tolist()
   _cd_series = pd.Series(_cur_count_series, index=_cur_date_series)
   pay_index = pd.DatetimeIndex([_cd_series.index[0], _cd_series.index[len(_cd_series)-1]])
   _pay_series = pd.Series([0, 0], index=pay_index).resample('D', ).pad()
   for time in _cd_series.index:
      _pay_series[time] = _cd_series[time]
   pay_cur_date_series = _pay_series.index
   pay_cur_count_series = _pay_series.values
   ########################################################################################################################
   figure_name =figure_pay_path + str(shop_id) + '_view_time.png'
   view_ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d') )
   view_ax.plot_date(view_cur_date_series,view_cur_count_series,'m-', marker='.',linewidth=1);
   view_ax.plot_date(pay_cur_date_series, pay_cur_count_series, 'k-', marker='.',linewidth=1);
   print figure_name
   plt.savefig(figure_name)
   view_ax.clear()
Beispiel #33
0
def return_date_list(start, end):
    delta = datetime.timedelta(days=1) # set increment as one day
    float_date_list = drange(start, end, delta)

    date_list = []
    for day in range(len(float_date_list)):
        # create a dates list with YYYY-MM-DD date format
        date_list.append(date.fromordinal(int(float_date_list[day])).strftime('%Y-%m-%d'))

    return date_list
Beispiel #34
0
def newusersEvolution(cursor=None, title=''):
    result = cursor.execute("SELECT STRFTIME('%Y-%m-%d', rev_timestamp) AS date, rev_user_text FROM revision WHERE 1 ORDER BY date ASC")
    newusers = {}
    for row in result:
        if not newusers.has_key(row[1]):
            newusers[row[1]] = datetime.date(year=int(row[0][0:4]), month=int(row[0][5:7]), day=int(row[0][8:10]))
    
    newusers2 = {}
    for newuser, date in newusers.items():
        if newusers2.has_key(date):
            newusers2[date] += 1
        else:
            newusers2[date] = 1
    
    newusers_list = [[x, y] for x, y in newusers2.items()]
    newusers_list.sort()
    
    startdate = newusers_list[0][0]
    enddate = newusers_list[-1:][0][0]
    delta = datetime.timedelta(days=1)
    newusers_list = [] #reset, adding all days between startdate and enddate
    d = startdate
    while d < enddate:
        if newusers2.has_key(d):
            newusers_list.append([d, newusers2[d]])
        else:
            newusers_list.append([d, 0])
        d += delta
    
    import pylab
    from matplotlib.dates import DateFormatter, rrulewrapper, RRuleLocator, drange

    loc = pylab.MonthLocator(bymonth=(1,6))
    formatter = DateFormatter('%Y-%m-%d')
    dates = drange(startdate, enddate, delta)

    fig = pylab.figure()
    ax = fig.add_subplot(1,1,1)
    ax.set_ylabel('Newusers')
    ax.set_xlabel('Date (YYYY-MM-DD)')
    print '#'*100
    print len(dates)
    print dates
    print '#'*100
    print len(pylab.array([y for x, y in newusers_list]))
    print pylab.array([y for x, y in newusers_list])
    print '#'*100
    pylab.plot_date(dates, pylab.array([y for x, y in newusers_list]), 'o', color='green')
    ax.xaxis.set_major_locator(loc)
    ax.xaxis.set_major_formatter(formatter)
    ax.set_title(title)
    ax.grid(True)
    ax.set_yscale('log')
    labels = ax.get_xticklabels()
    pylab.setp(labels, rotation=30, fontsize=10)
    def getEmptyTimeArrayRange(sampleMeasurement, interval, startDate,
                               endDate):
        """ Use the mat lab dates function instead of a loop to make the array
        Use this to test the speed difference"""
        newStartTime = CbibsStationJsonMgr.getStartDate(
            sampleMeasurement, startDate, interval)
        endDate = endDate.replace(tzinfo=pytz.utc)

        # Generate a series of dates (these are in matplotlib's internal date format)
        emptyArray = mdates.drange(newStartTime, endDate,
                                   datetime.timedelta(minutes=(interval / 60)))
        return emptyArray
Beispiel #36
0
def newpagesEvolution(cursor=None, title=''):
    result = cursor.execute(
        "SELECT STRFTIME('%Y-%m-%d', page_creation_timestamp) AS date, COUNT(*) AS count FROM page WHERE 1 GROUP BY date ORDER BY date ASC"
    )
    newpages = {}
    for row in result:
        d = datetime.date(year=int(row[0][0:4]),
                          month=int(row[0][5:7]),
                          day=int(row[0][8:10]))
        newpages[d] = row[1]

    newpages_list = [[x, y] for x, y in newpages.items()]
    newpages_list.sort()

    startdate = newpages_list[0][0]
    enddate = newpages_list[-1:][0][0]
    delta = datetime.timedelta(days=1)
    newpages_list = []  #reset, adding all days between startdate and enddate
    d = startdate
    while d < enddate:
        if newpages.has_key(d):
            newpages_list.append([d, newpages[d]])
        else:
            newpages_list.append([d, 0])
        d += delta

    import pylab
    from matplotlib.dates import DateFormatter, rrulewrapper, RRuleLocator, drange

    loc = pylab.MonthLocator(bymonth=(1, 6))
    formatter = DateFormatter('%Y-%m-%d')
    dates = drange(startdate, enddate, delta)

    fig = pylab.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax.set_ylabel('Newpages')
    ax.set_xlabel('Date (YYYY-MM-DD)')
    print '#' * 100
    print len(dates)
    print dates
    print '#' * 100
    print len(pylab.array([y for x, y in newpages_list]))
    print pylab.array([y for x, y in newpages_list])
    print '#' * 100
    pylab.plot_date(dates, pylab.array([y for x, y in newpages_list]), 'o')
    ax.xaxis.set_major_locator(loc)
    ax.xaxis.set_major_formatter(formatter)
    ax.set_title(title)
    ax.grid(True)
    ax.set_yscale('log')
    labels = ax.get_xticklabels()
    pylab.setp(labels, rotation=30, fontsize=10)
def plotmap(df, color, cbarlabel, xaxislabel, yaxislabel, graphiclabel,
            filelabel):

    import matplotlib.dates as mdates
    from matplotlib import ticker
    import datetime
    import matplotlib
    import seaborn as sns

    # Set up the size/style
    sns.set(rc={"figure.figsize": (12, 15)})
    sns.set_style("whitegrid")

    numberofplots = 1

    fig = plt.figure()

    x = mdates.drange(df.index[0], df.index[-1] + datetime.timedelta(days=1),
                      datetime.timedelta(days=1))
    y = np.linspace(0, len(df.columns), len(df.columns) + 1)
    ax = fig.add_subplot(numberofplots, 1, 1)
    data = np.array(df.T)
    datam = np.ma.array(data, mask=np.isnan(data))
    cmap = matplotlib.cm.get_cmap(color)
    qmesh = ax.pcolormesh(x, y, datam, cmap=cmap)

    cbaxes = fig.add_axes([0.15, 0.15, 0.7, 0.02])
    cbar = fig.colorbar(qmesh, ax=ax, orientation='horizontal', cax=cbaxes)

    cbar.ax.tick_params(length=0)
    cbar.set_label(cbarlabel)

    ax.axis('tight')
    ax.xaxis_date()
    fig.autofmt_xdate()
    fig.subplots_adjust(hspace=.5)
    ax.set_xlabel(xaxislabel)
    ax.set_ylabel(yaxislabel)
    ax.set_title(graphiclabel)

    ax.set_yticklabels(df.columns)
    tick_locator = ticker.MaxNLocator(nbins=110)
    loc = ticker.MultipleLocator(
        base=1.0)  # this locator puts ticks at regular intervals
    ax.locator_params(axis='y', nbins=100)
    myFmt = mdates.DateFormatter('%b')
    ax.xaxis.set_major_formatter(myFmt)

    #     T=np.arange(len(df.columns))+0.5
    #     ax.set_yticks(T)
    #     plt.tight_layout()
    plt.subplots_adjust(bottom=0.2)
def get_time_axis(data1, data2):
    '''
    Get the time-axis to create the stem plot.
    It is will have a regulized time interval of 1 day.

    "data" - a dictornary that stores the required date info as it's values.
    '''
    all_dates = set(data1.values()).union(set(data2.keys()))
    dstart = datetime.strptime(min(all_dates), "%Y-%m-%d")
    dend = datetime.strptime(max(all_dates), "%Y-%m-%d") + timedelta(days=1)
    delta = timedelta(days=1)
    time_axis_md = mdates.drange(dstart, dend, delta)
    time_axis_py = mdates.num2date(time_axis_md, tz=None)
    return time_axis_py
Beispiel #39
0
def gen_data(date_current,type,precision):
    data_to_process =[] #debugging
    delta = datetime.timedelta(minutes = precision) #debugging
    if type == 'dayh':
        date_previous   = date_current - datetime.timedelta(days=1)
        for item in drange(date_previous,date_current + datetime.timedelta(days=1),delta): #debugging
            data_to_process.append({'datetimestamp':num2date(item),'Pactiva':1}) #debugging
    elif type == 'week':
        date_previous   = (date_current -datetime.timedelta(days=7+date_current.weekday()))
        for item in drange(date_previous,date_current + datetime.timedelta(days=1),delta): #debugging
            data_to_process.append({'datetimestamp':num2date(item),'Pactiva':1}) #debugging
    elif type == 'month':
        if date_current.month  < 2:
            date_previous   = date_current.replace(year=date_current.year-1,month=12,day=1)
        else:
            date_previous   = date_current.replace(month=date_current.month - 1,day=1)
        for item in drange(date_previous,date_current + datetime.timedelta(days=1),delta): #debugging
            data_to_process.append({'datetimestamp':num2date(item),'Pactiva':1}) #debugging
    elif type == 'year':
        date_previous   = date_current.replace(year=date_current.year - 1,month=1,day=1)
        for item in drange(date_previous,date_current + datetime.timedelta(days=1),delta): #debugging
            data_to_process.append({'datetimestamp':num2date(item),'Pactiva':1}) #debugging
    return data_to_process
Beispiel #40
0
def newpagesEvolution(cursor=None, title=""):
    result = cursor.execute(
        "SELECT STRFTIME('%Y-%m-%d', page_creation_timestamp) AS date, COUNT(*) AS count FROM page WHERE 1 GROUP BY date ORDER BY date ASC"
    )
    newpages = {}
    for row in result:
        d = datetime.date(year=int(row[0][0:4]), month=int(row[0][5:7]), day=int(row[0][8:10]))
        newpages[d] = row[1]

    newpages_list = [[x, y] for x, y in newpages.items()]
    newpages_list.sort()

    startdate = newpages_list[0][0]
    enddate = newpages_list[-1:][0][0]
    delta = datetime.timedelta(days=1)
    newpages_list = []  # reset, adding all days between startdate and enddate
    d = startdate
    while d < enddate:
        if newpages.has_key(d):
            newpages_list.append([d, newpages[d]])
        else:
            newpages_list.append([d, 0])
        d += delta

    import pylab
    from matplotlib.dates import DateFormatter, rrulewrapper, RRuleLocator, drange

    loc = pylab.MonthLocator(bymonth=(1, 6))
    formatter = DateFormatter("%Y-%m-%d")
    dates = drange(startdate, enddate, delta)

    fig = pylab.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax.set_ylabel("Newpages")
    ax.set_xlabel("Date (YYYY-MM-DD)")
    print "#" * 100
    print len(dates)
    print dates
    print "#" * 100
    print len(pylab.array([y for x, y in newpages_list]))
    print pylab.array([y for x, y in newpages_list])
    print "#" * 100
    pylab.plot_date(dates, pylab.array([y for x, y in newpages_list]), "o")
    ax.xaxis.set_major_locator(loc)
    ax.xaxis.set_major_formatter(formatter)
    ax.set_title(title)
    ax.grid(True)
    ax.set_yscale("log")
    labels = ax.get_xticklabels()
    pylab.setp(labels, rotation=30, fontsize=10)
Beispiel #41
0
def graphcoord_time(axis):
	time = mdates.drange(datetime.datetime(2014, 10, 21, 16), 
                     datetime.datetime(2014, 10, 25, 16),
                     datetime.timedelta(minutes=15))

	fig = plt.figure()

	plt.plot_date(time, vector.T[axis]/50000, 'b-')
	plt.ylabel(axis)
	# 2014-10-23T08:30:24Z
	plt.axvline(datetime.datetime(2014, 10, 23, 8, 30, 24))

	fig.autofmt_xdate()
	plt.show()
Beispiel #42
0
def convertPythonDateTime(DateTime):
    # Since it looks like matplotlib.dates.formatter does not work on work in mpld3...
    # I have to manually make a function    
    print DateTime
    delta = datetime.timedelta(days=1)
    startDate = datetime.date(2015,5,5)#mdates.num2epoch(0)
    endDate = datetime.date(2016,3,5)#mdates.num2epoch(DateTime[-1])
    print delta
    print startDate
    print endDate
    newDate = mdates.drange(startDate, endDate, delta)
    print 'test'

    return newDate 
Beispiel #43
0
def makeFakeRainData():
    tdelta = dt.datetime(2001, 1, 1, 1, 5) - dt.datetime(2001, 1, 1, 1, 0)
    start = dt.datetime(2001, 1, 1, 12, 0)
    end = dt.datetime(2001, 1, 1, 16, 0)
    daterange_num = mdates.drange(start, end, tdelta)
    daterange = mdates.num2date(daterange_num)

    rain_raw = [
        0., 1., 2., 3., 4., 4., 4., 4., 4., 4., 4., 4., 0., 0., 0., 0., 0., 5.,
        5., 5., 5., 5., 5., 5., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        1., 2., 3., 0., 0., 0., 0., 0., 0., 0., 0., 0.
    ]

    return daterange, rain_raw
Beispiel #44
0
def makeFakeRainData():
    tdelta = dt.datetime(2001, 1, 1, 1, 5) - dt.datetime(2001, 1, 1, 1, 0)
    start = dt.datetime(2001, 1, 1, 12, 0)
    end = dt.datetime(2001, 1, 1, 16, 0)
    daterange_num = mdates.drange(start, end, tdelta)
    daterange = mdates.num2date(daterange_num)

    rain_raw = [
        0.,  1.,  2.,  3.,  4.,  4.,  4.,  4.,  4.,  4.,  4.,  4.,
        0.,  0.,  0.,  0.,  0.,  5.,  5.,  5.,  5.,  5.,  5.,  5.,
        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,
        1.,  2.,  3.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]

    return daterange, rain_raw
Beispiel #45
0
def graphcoord_time(axis):
    time = mdates.drange(datetime.datetime(2014, 10, 21, 16),
                         datetime.datetime(2014, 10, 25, 16),
                         datetime.timedelta(minutes=15))

    fig = plt.figure()

    plt.plot_date(time, vector.T[axis] / 50000, 'b-')
    plt.ylabel(axis)
    # 2014-10-23T08:30:24Z
    plt.axvline(datetime.datetime(2014, 10, 23, 8, 30, 24))

    fig.autofmt_xdate()
    plt.show()
    def get_commit_by_date(self):
        
        numdates = drange(self.start_date, self.stop_date, timedelta(days=1))

        numcommits = [0 for i in numdates]
        
        for rev, time, author in self.changesets:
            
            date = to_datetime(time, utc).date()
            #get index of day in the dates list
            index = bisect(numdates, date2num(date)) - 1     
            
            numcommits[index] += 1
        
        return (numdates, numcommits)
Beispiel #47
0
def graph_orders(orders):
    fig = figure()
    ax = fig.add_subplot(111)

    for market, res in orders.iteritems():
        dates  = [r[0] for r in res]
        counts = [r[1] for r in res]
        oneday = timedelta(days=1)
        x = drange(min(dates), max(dates) + oneday, oneday)

        ax.plot_date(x, counts, '-')

    ax.xaxis.set_major_locator(DayLocator())
    ax.xaxis.set_major_formatter(DateFormatter("%x"))

    show()
def Plotzerosnowdays(data,beginyear,endyear): #function does not work with python 3....maybe problem with inputs
    date1 = dt.date(beginyear,1,1)
    date2 = dt.date(endyear+1,1,1)
    delta = dt.timedelta(days=1)    
    datearray = mdates.drange(date1,date2,delta) #create date array
    zerosnowvalues = np.zeros(len(datearray)) #store zero snow days
    for i in range(len(datearray)):
        for j in range(len(data)):
            m,d,y = Dateformat(data[j])
            datenum = mdates.date2num(dt.date(y,m,d))
            if (datearray[i] == datenum):
                zerosnowvalues[i] = 1  #count day as zero snow
    datearray = mdates.num2date(datearray)
    plt.plot(datearray,zerosnowvalues)
    plt.ylim(0,2)
    return()   
Beispiel #49
0
def makeMiddlePoint(li,delta):
	'''
	引数:
		li:リスト
		delta:datetime
	戻り値:twoの間に入れる値をyield
	'''
	for two in list(pairwise(li)):   #liの中身を2つずつにわける
		if two[-1]-two[0]>=delta +timedelta(minutes=1):   #抜き出したタプルの要素の差がdelta上であれば
			print('\nLack between %s and %s'% (two[0],two[1]))
			print('Substract',abs(two[0]-two[1]))
			for i in pltd.drange(two[0]+delta,two[-1],delta):
				li.insert(li.index(two[-1]),pltd.num2date(i))   #タプルの要素間の場所にdeltaずつ増やした値を入れる
				print('insert',pltd.num2date(i))
				yield pltd.num2date(i).strftime('%Y%m%d_%H%M%S')
	print('\nThere is No point to insert')
	print('makeMiddlePoint END\n')
Beispiel #50
0
def build(ax1, servicio, unit):
    fechas, consumos = zip(*sorted(servicio.items()))

    f = interp1d(date2num(fechas), consumos)          # generate interpolation func
    x = drange(fechas[0], fechas[-1], tdelta(days=1)) # generate range of points

    ax1.plot_date(fechas, consumos, 'g-')       # plot original data
    ax1.set_ylabel('Consumo en ' + unit, color='g')

    ax2 = ax1.twinx()
    ax2.plot(x, np.gradient(f(x)), 'b-')
    ax2.set_ylabel(unit + ' / dia', color='b')       # plot rate of change

    dt = date2num((fechas[0], fechas[-1]))
    dc = (consumos[-1] - consumos[0]) / (date2num(fechas[-1]) - date2num(fechas[0]))

    ax3 = ax1.twinx()
    ax3.plot(dt, (dc, dc), 'r-')
    ax3.set_ylabel(unit + '/dia periodo', color='r') # plot rate of change
Beispiel #51
0
def plot_angles_from_csv_file(fnames):
    
    majorLocator = MultipleLocator(12)
    majorFormatter = FormatStrFormatter('%d')
    minorLocator = MultipleLocator(2)
        
    fig, ax = plt.subplots(nrows=4, ncols=1, sharex=True)
    
    alldays = DayLocator()

    date1 = datetime.datetime(2016, 3, 10)
    date2 = datetime.datetime(2016, 3, 14)
    delta = datetime.timedelta(hours=24)
    dates = drange(date1, date2, delta)

    dfs = []
    for fname in fnames:
        df = pd.read_csv(fname)
        dfs.append(df)
    
    # FIXME quick kludge for getting timing wrangled between data sets
    if os.path.basename(fnames[0]).startswith('anglesS'):
        dfs[3] = dfs[3].reindex(index=dfs[3].index.union(dfs[2].index).union(dfs[1].index).union(dfs[0].index))
    elif os.path.basename(fnames[0]).startswith('anglesP'):
        dfs[0] = dfs[0].reindex(index=dfs[0].index.union(dfs[2].index).union(dfs[1].index).union(dfs[3].index))
    else:
        raise Exception('unexpected basename for CSV file')
    
    dfs[0].plot(ax=ax[0], x='GMT', y='Angle_deg')
    dfs[1].plot(ax=ax[1], x='GMT', y='Angle_deg')
    dfs[2].plot(ax=ax[2], x='GMT', y='Angle_deg')
    dfs[3].plot(ax=ax[3], x='GMT', y='Angle_deg')
    
    # set common labels
    for a in ax:
        a.set_ylabel('Angle (deg.)')
        a.legend().set_visible(False)
        print a.get_xlim()


    ax[3].set_xlabel('GMT')
        
    plt.show()
Beispiel #52
0
def print_periods( id, periods ):
    for k,v in periods.items():
        print(
                id,'%02d' % k,v['id'],':',
                v['start_date'].strftime('%Y-%m-%d'),
                v['end_date'].strftime('%Y-%m-%d'),
                'kms:', '% 6.1f' % v['kms'],
                'time:', v['time']
              )
       
    x = []
    y = []       
    for k,v in periods.items():
        x.append(v['end_date'])
        y.append(v['kms'])
        
    dates = drange(x)
    plt.bar(dates, y, width = 1, align='center')
#     plt.plot(x, y)
    plt.show()
    def analyzeStatsForGlobalClassifier():
        dataToPlot=dict()
        for l in Utilities.iterateJsonFromFile(Settings.stats_for_global_classifier): dataToPlot[datetime.strptime(l['day'], Settings.twitter_api_time_format)]=l['value']
        
        date1 = Settings.startTime
        date2 = Settings.endTime
        dates = drange(date1, date2, timedelta(days=1))
        
        print len(dates), len(dataToPlot)
        fig=plt.figure()
#        plt.plot_date(dates, [1 for k in dates], '-')
        plt.plot_date(dates, [dataToPlot[k] for k in sorted(dataToPlot)[:-1]], 'g-', lw=2, label='Global classifier (mean:%0.2f)'%numpy.mean(dataToPlot.values()))
#        plt.plot_date(dates, [0 for k in dates], '-')
        plt.ylim((0.4,0.55))
        plt.ylabel('AUCM value')
        plt.xlabel('Day')
        plt.title('AUCM values for global classifier.')
        plt.legend()
        fig.autofmt_xdate()
        plt.show()
Beispiel #54
0
def fill(li,delta):
	'''
	引数:
		li:リスト
		delta:intまたはdatetime
	戻り値:twoの間に入れる値をyield
	'''
	for two in list(pairwise(li)):   #liの中身を2つずつにわける
		print(two)
		if two[-1]-two[0]>delta:   #抜き出したタプルの要素の差がdelta上であれば
			if type(two[0])==datetime:
				for i in pltd.drange(two[0]+delta,two[-1],delta):
					li.insert(li.index(two[-1]),pltd.num2date(i))   #タプルの要素間の場所にdeltaずつ増やした値を入れる
					# print('insert',pltd.num2date(i))
					yield pltd.num2date(i)
			else :
				for i in range(two[0]+delta,two[-1],delta):
					li.insert(li.index(two[-1]),i)   #タプルの要素間の場所にdeltaずつ増やした値を入れる
					# print('insert',i)
					yield i
Beispiel #55
0
def plot_each_device(sc, unctrl, cntrl):
    t = drange(sc.t_start, sc.t_end, timedelta(minutes=1))
    for d_unctrl, d_ctrl in zip(unctrl, ctrl):
        fig, ax = plt.subplots(2, sharex=True)
        ax[0].set_ylabel('P$_{el}$ [kW]')
        ymax = max(d_unctrl[0].max(), d_ctrl[0].max()) / 1000.0
        ax[0].set_ylim(-0.01, ymax + (ymax * 0.1))
        ax[0].plot_date(t, d_unctrl[0] / 1000.0, fmt='-', lw=1, label='unctrl')
        ax[0].plot_date(t, d_ctrl[0] / 1000.0, fmt='-', lw=1, label='ctrl')
        leg0 = ax[0].legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=4,
                            borderaxespad=0.0, fancybox=False)

        ax[1].set_ylabel('T$_{storage}$ [\\textdegree C]')
        ax[1].plot_date(t, d_unctrl[2] - 273.0, fmt='-', lw=1, label='unctrl')
        ax[1].plot_date(t, d_ctrl[2] - 273.0, fmt='-', lw=1, label='ctrl')

        fig.autofmt_xdate()
        for label in leg0.get_texts():
            label.set_fontsize('x-small')
        fig.subplots_adjust(left=0.1, right=0.95, top=0.88, bottom=0.2)
Beispiel #56
0
    def run(self):
        """ start ECG plotting """

        # continue doing this method until DAQ is stopped
        while not self.stopPlotThread.isSet():

            # call the plot method to start plotting
            self.parentFrame.ecgplotter.plot()
            # check if the thread has been stopped. if yes, no need to update endtime. 
            if not self.stopPlotThread.isSet():
                self.parentFrame.ecgplotter.endtime += datetime.timedelta(seconds = 15)
                # initialize the time size (nagiiba kase after every 15 seconds. needs to be extended
                self.parentFrame.ecgplotter.timeaxis = num2date(drange(self.parentFrame.ecgplotter.starttime, self.parentFrame.ecgplotter.endtime, datetime.timedelta(milliseconds = 10)))
                
            else:
                break
            
        # add slider at the end of plotting only
        self.parentFrame.ecgplotter.addSlider(self.parentFrame.ecgplotter.endtime)
        # redraw the plotting window to make the slider appear
        self.parentFrame.ecgplotter.canvas.draw()
        self.parentFrame.ecgplotter.canvas.gui_repaint()
Beispiel #57
0
def plot_slp(sc, bd):
    slp = _read_slp(sc, bd)

    res = 1
    if (sc.t_end - sc.t_start).total_seconds() / 60 == slp.shape[-1] * 15:
        res = 15
    t = drange(sc.t_start, sc.t_end, timedelta(minutes=res))

    fig, ax = plt.subplots()
    ax.set_ylabel('P$_{el}$ [kW]')
    ymax = max(slp.max(), slp.max())
    ymin = min(slp.min(), slp.min())
    ax.set_ylim(ymin - (ymin * 0.1), ymax + (ymax * 0.1))
    ax.plot_date(t, slp, fmt='-', lw=1, label='H0')
    leg0 = ax.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=4,
                        borderaxespad=0.0, fancybox=False)

    fig.autofmt_xdate()
    for label in leg0.get_texts():
        label.set_fontsize('x-small')
    fig.subplots_adjust(left=0.1, right=0.95, top=0.88, bottom=0.2)

    return fig
Beispiel #58
0
    def initPlot(self):
        """ redraw the canvas to set the initial x and y axes when plotting starts """

        # set the reference time of plotting
        self.starttime = datetime.datetime.today()
        self.starttime_tick = time.mktime(self.starttime.timetuple())

        # set the current time of plotting (located at the end point of the plotter window)
        self.currenttime = self.starttime + datetime.timedelta(seconds = 3)
        self.currenttime_tick = time.mktime(self.currenttime.timetuple())

        # set the time-value array for 15-second (equivalent to a duration of 1 EDF file)
        self.endtime = self.starttime + datetime.timedelta(seconds = 15)
        self.timeaxis = num2date(drange(self.starttime, self.endtime, datetime.timedelta(milliseconds = 10)))

        # append samples of x and y-axes to be plotted
        self.xvalues.append(self.timeaxis[0])
        self.yvalues.append(self.parentPanel.myECG.ecg_leadII[0])

        self.ybuffer = self.yvalues

        # set the new data to be plotted (based from the updated values of xvalues and yvalues array)
        self.lines[0].set_data(self.xvalues, self.yvalues)

        # set the plotter window limit to 3-second
        self.axes.set_xlim((date2num(self.starttime),date2num(self.currenttime)))

        # update the x-axis ticklabels depending on the current time of plotting
        self.axes.xaxis.set_ticklabels(self.createXTickLabels(self.currenttime_tick), rotation = 30, ha = "right", size = 'smaller', name = 'Calibri')

        self.samples_counter += 1
        self.ysamples_counter += 1
        self.buff_counter = 1

        #for filtering
        self.startfil = 0
        self.endfil = 1500
Beispiel #59
0
def plot_time_data(date_in,date_end,delta,data_y):
    ''' plot data against detetime values, provide date_initial and final
    '''
    date1 = date_in
    date2 = date_end
    delta= datetime.timedelta(minutes=5)
    
    dates = drange(date1, date2, delta)
    fig = figure()
    ax = fig.add_subplot(111)
    if (len(dates)<>len(data_y[0:len(dates)])):
        print "error, len dates", len(dates)
        print "len dati ", len(data_y[0:len(dates)])
    ax.plot_date(dates, data_y[0:len(dates)],'-')
    ax.set_xlim( dates[0], dates[-1] )
    ax.xaxis.set_major_locator( DayLocator() )
    ax.xaxis.set_minor_locator( HourLocator())
    ax.xaxis.set_minor_formatter( DateFormatter('%H') )
    ax.xaxis.set_major_formatter( DateFormatter('%Y-%m-%d') )
    
    ax.fmt_xdata = DateFormatter('%Y-%m-%d %H:%M')
    
    fig.autofmt_xdate()
    show()
def time2():
    import datetime
    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib.dates as mpldates
    import matplotlib.ticker as ticker
    
    date1 = datetime.date( 1952, 1, 1 )
    date2 = datetime.date( 2004, 4, 12 )
    delta = datetime.timedelta(days=100)
    dates = mpldates.drange(date1, date2, delta)
    s1 = np.random.rand(len(dates))
    
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.plot_date(dates, s1,'r.')
    ax.hold(True)
    s2 = np.random.rand(len(dates))
    ax.plot_date(dates, s2,'bo')
    ax.legend(('s1','s2'), numpoints=1)
    
    # only write ticklabels on the decades
    def fmtticks(x, pos=None):
        dt = mpldates.num2date(x)
        if dt.year%10: return ''
        return dt.strftime('%Y')
    
    # this fizes yhe tick labels
    ax.xaxis.set_major_formatter(ticker.FuncFormatter(fmtticks))
    
    # this fixes the toolbar x coord
    ax.fmt_xdata = mpldates.DateFormatter('%Y-%m-%d')
    
    # this rotates the ticklabels to help with overlapping
    fig.autofmt_xdate()
    plt.show()