Exemple #1
0
def plot_throughput_vary_size(exp_idxs, labels, tx, sizes, rp, num_of_server,
                              fig_num):
    assert len(exp_idxs) == len(labels)
    alo_lists = [
        get_throughput_vary_size(idx, tx, sizes, rp) for idx in exp_idxs
    ]

    fig, axs = plt.subplots(figsize=fig_size)

    for j, alo_list in enumerate(alo_lists):
        axs.plot(sizes,
                 alo_list,
                 colors[j],
                 marker=markers[j],
                 label=labels[j],
                 linestyle=linestyle,
                 linewidth=linewidth,
                 markersize=markersize)
    # axs.legend(loc='upper center', bbox_to_anchor=(0.5, 1),
    #       ncol=4, fancybox=True, shadow=True, prop={'size': 8})  ##

    axs.legend(loc='upper left', ncol=legend_ncol, prop=legend_prop)  ##
    axs.set_xlabel(vary_szs_x_label(num_of_server, tx, rp), fontsize=fontsize)
    plt.xscale('log')
    plt.xticks(sizes, tuple(sizes))
    plt.minorticks_off()
    plt.ylim(0, 5000)

    axs.set_ylabel("throughput (ops/sec)", fontsize=fontsize)
    plt.grid(color='tab:gray', linestyle=':', linewidth=0.8)
    plt.tight_layout()
    plt.savefig(f"LAN_{fig_num}_throughput,_vary_size,_{num_of_server}_svrs")
    plt.show()
def plotMatches(listofaValues, listofNValues, errors,
                fileName = "images/scalar_effect_of_n.pdf"):
  fig, ax = plt.subplots()

  fig.suptitle("Match probability for sparse vectors")
  ax.set_xlabel("Dimensionality (n)")
  ax.set_ylabel("Frequency of matches")
  ax.set_yscale("log")

  ax.plot(listofNValues, errors[0,:], 'k:',
          label="a=64 (predicted)", marker="o", color='black')
  ax.plot(listofNValues, errors[1,:], 'k:',
          label="a=128 (predicted)", marker="o", color='black')
  ax.plot(listofNValues, errors[2,:], 'k:',
          label="a=256 (predicted)", marker="o", color='black')
  ax.plot(listofNValues, errors[3,:], 'k:',
          label="a=n/2 (predicted)", marker="o", color='black')

  ax.annotate(r"$a = 64$", xy=(listofNValues[3]+100, errors[0,3]),
              xytext=(-5, 2), textcoords="offset points", ha="left",
              color='black')
  ax.annotate(r"$a = 128$", xy=(listofNValues[3]+100, errors[1,3]),
               ha="left",color='black')
  ax.annotate(r"$a = 256$", xy=(listofNValues[3]+100, errors[2,3]),
               ha="left",color='black')
  ax.annotate(r"$a = \frac{n}{2}$", xy=(listofNValues[3]+100, errors[3,3]),
               ha="left",color='black')

  plt.minorticks_off()
  plt.grid(True, alpha=0.3)

  plt.savefig(fileName)
  plt.close()
Exemple #3
0
def plot_half_log_fit(R, T, fig, R_type):
    plt.figure(fig)
    [log_base, log_coefficient], errors = fit_line(T, np.log(R))

    base, coefficient = np.exp([log_base, log_coefficient])
    coefficient_low_err = coefficient - np.exp(log_coefficient - errors[0])
    coefficient_high_err = np.exp(log_coefficient + errors[0]) - coefficient
    base_low_err = base - np.exp(log_base - errors[1])
    base_high_err = np.exp(log_base + errors[1]) - base

    plot_range = (min(T), max(T))

    plot_func(lambda x: coefficient * np.power(base, x), plot_range)
    plt.scatter(T, R, c='g')
    plt.semilogy()
    plt.minorticks_off()
    plt.yticks(np.linspace(round(0.9 * min(R), 0), round(1.05 * max(R), 0), 5))
    plt.xticks(np.linspace(round(plot_range[0], 0), round(plot_range[1], 0),
                           5))
    plt.grid(True, which='both')

    #    coefficient_err_str = '$^{' + f'{coefficient_high_err:.2f}' + '}_{' + f'{coefficient_low_err:.2f}' + '}$'
    #    base_err_str = '$^{' + f'{base_high_err:.2f}' + '}_{' + f'{base_low_err:.2f}' + '}$'

    plt.xlabel('$\mathbb{\Delta}$T[°C]')
    plt.ylabel('R[$\mathbb{\Omega}$]')
def draw_lines(line_data, path, y_min, y_max, is_log=False, flag=0):
    plt.figure(figsize=(7, 4.2))

    for i in range(0, len(line_data)):
        plt.plot(x,
                 line_data[i],
                 label=line_legends[i],
                 color=line_colors[i],
                 marker=line_markers[i],
                 markersize=10,
                 fillstyle='none',
                 linestyle='--')

    if is_log:
        plt.yscale('log')
    plt.minorticks_off()
    plt.xlabel(x_label, fontsize=18)
    plt.ylabel(y_label[flag], fontsize=18)
    plt.xticks(x, x_tick_labels, fontsize=18)
    plt.yticks(fontsize=18)

    plt.ylim(y_min, y_max)
    plt.xlim(min(x) - 0.25, max(x) + 0.25)
    plt.legend(loc=0,
               ncol=3,
               fontsize=18,
               frameon=False,
               handletextpad=0.1,
               columnspacing=1.0,
               handlelength=1.5)
    plt.grid()
    plt.tight_layout()
    # plt.show()
    plt.savefig(path)
    plt.close()
def plotLog(filename, watch=False, **kargs):
    fig, ax = plt.subplots(1,1)
    fig.subplots_adjust(hspace=0)
    plt.show(block=False)
    while True:
        with open(filename, 'r') as f:
            names = f.readline().rstrip().split('\t')
        df = pd.read_csv(filename, skiprows=1, delimiter='\t', parse_dates=[0], na_values="<undefined>", names=names)
        #df = df.dropna()
        ax2 = df.plot("Time", subplots=True, ax=ax, sharex=True)
        dt = df.iloc[-1,0]-df.iloc[0,0]
        for a in ax2:
            if dt.seconds < 15*60:
                a.xaxis.set_major_locator(mpl.dates.MinuteLocator(interval=1))
            elif dt.seconds < 3*60*60:
                a.xaxis.set_major_locator(mpl.dates.MinuteLocator(interval=5))
            else:
                a.xaxis.set_major_locator(mpl.dates.MinuteLocator(interval=15))
            a.xaxis.set_major_formatter(mpl.dates.DateFormatter('%H:%M'))
            a.grid()
        plt.minorticks_off()

        if watch:
            mypause(3)
        else:
            plt.show()
        if not watch:
            break
def plotLog(filename, watch=False, **kargs):
    fig, ax = plt.subplots(1,1)
    fig.subplots_adjust(hspace=0)
    plt.show(block=False)
    while True:
        with open(filename, 'r') as f:
            names = f.readline().rstrip().split('\t')
        df = pd.read_csv(filename, skiprows=1, delimiter='\t', parse_dates=[0], na_values="<undefined>", names=names)
        #df = df.dropna()
        ax2 = df.plot("Time", subplots=True, ax=ax, sharex=True)
        dt = df.iloc[-1,0]-df.iloc[0,0]
        for a in ax2:
            if dt.seconds < 15*60:
                a.xaxis.set_major_locator(mpl.dates.MinuteLocator(interval=1))
            elif dt.seconds < 3*60*60:
                a.xaxis.set_major_locator(mpl.dates.MinuteLocator(interval=5))
            else:
                a.xaxis.set_major_locator(mpl.dates.MinuteLocator(interval=15))
            a.xaxis.set_major_formatter(mpl.dates.DateFormatter('%H:%M'))
            a.grid()
        plt.minorticks_off()

        if watch:
            mypause(3)
        else:
            plt.show()
Exemple #7
0
def plotMatches(listofaValues,
                listofNValues,
                errors,
                fileName="images/scalar_effect_of_n.pdf"):
    fig, ax = plt.subplots()

    fig.suptitle("Match probability for sparse vectors")
    ax.set_xlabel("Dimensionality (n)")
    ax.set_ylabel("Frequency of matches")
    ax.set_yscale("log")

    ax.plot(listofNValues,
            errors[0, :],
            'k:',
            label="a=64 (predicted)",
            marker="o",
            color='black')
    ax.plot(listofNValues,
            errors[1, :],
            'k:',
            label="a=128 (predicted)",
            marker="o",
            color='black')
    ax.plot(listofNValues,
            errors[2, :],
            'k:',
            label="a=256 (predicted)",
            marker="o",
            color='black')
    ax.plot(listofNValues,
            errors[3, :],
            'k:',
            label="a=n/2 (predicted)",
            marker="o",
            color='black')

    ax.annotate(r"$a = 64$",
                xy=(listofNValues[3] + 100, errors[0, 3]),
                xytext=(-5, 2),
                textcoords="offset points",
                ha="left",
                color='black')
    ax.annotate(r"$a = 128$",
                xy=(listofNValues[3] + 100, errors[1, 3]),
                ha="left",
                color='black')
    ax.annotate(r"$a = 256$",
                xy=(listofNValues[3] + 100, errors[2, 3]),
                ha="left",
                color='black')
    ax.annotate(r"$a = \frac{n}{2}$",
                xy=(listofNValues[3] + 100, errors[3, 3]),
                ha="left",
                color='black')

    plt.minorticks_off()
    plt.grid(True, alpha=0.3)

    plt.savefig(fileName)
    plt.close()
def draw(data, name):

    for i, d in enumerate(data):
        fig = plt.figure(figsize=(2, 10))
        ax = plt.subplot(111)
        ax.set_ylim((-70, 70))

        bars = ax.bar([0], [d], width=1, color='r' if d < 0 else 'g')
        ax.set_yscale('symlog')

        for rect in bars:
            height = rect.get_height()
            plt.text(rect.get_x() + rect.get_width() / 2.0,
                     height, ('' if height < 0 else '+') + '%d' % int(height),
                     ha='center',
                     va='bottom',
                     size=36,
                     color='w' if height < 0 else 'g')

        plt.gca().get_xaxis().set_ticks([])
        plt.gca().get_yaxis().set_ticks([])
        plt.minorticks_off()
        # plt.majorticks_off()
        plt.ylabel('Net Resource Collected', fontsize=36)

        plt.gca().spines['top'].set_visible(False)
        plt.gca().spines['right'].set_visible(False)
        plt.gca().spines['bottom'].set_visible(False)
        plt.gca().spines['left'].set_visible(False)
        ax.axhline(y=0, color='k')

        plt.tight_layout(pad=0.4)

        plt.savefig('img/explanatory_sep/' + name + '-' + str(i + 1) + '.pdf',
                    transparent=True)
def plot_export_txt(df: pd.DataFrame, file_name: str, config, timestamps):
    print('Creating plot for', file_name)

    df = df.query(config.query)

    axes = df.plot(subplots=True, sharex=True, figsize=(60, 15), title=file_name)

    # specify date format and tick interval
    date_format = '%H:%M:%S'
    tick_interval = 1500

    # select ticks from index
    ticks_to_use = df.index[::tick_interval]

    # create labels by reformatting the selected indices
    labels = [i.strftime(date_format) for i in ticks_to_use]
    ax = axes[0]  # First subplot, alternative = ax = plt.gca()

    # apply indices and matching labels to the plot
    ax.set_xticks(ticks_to_use)
    ax.set_xticklabels(labels, rotation=45)

    # rename x axis
    plt.xlabel('Zeitpunkt')

    # disable minor ticks that would interfere with new ticks
    plt.minorticks_off()

    for i in range(len(timestamps)):
        c = 'g' if i % 2 == 0 else 'r'
        plt.axvline(x=timestamps[i], linewidth=1, color=c, ls='--')
        # plt.axvline(x=row['ts_end'], linewidth=0.5, color='r', ls='--')

    plt.show()
Exemple #10
0
 def set_yticks(self, yticks, index=None, rotation='horizontal'):
     if index == None:
         plt.yticks(np.arange(len(yticks)), yticks, rotation=rotation)
     else:
         plt.yticks(index, yticks, rotation=rotation)
         #plt.locator_params(numticks=len(index))
         plt.minorticks_off()
def plot_oligo_rate_histo(norm_data):
    # norm_data = []
    bins_bound = np.linspace(0, 5, 36)
    # n, bins, patches = plt.hist(slopes, bins_bound, normed=True, stacked = True)
    # total = sum(n)
    # for i in range(len(n)):
    #     norm = (n[i] / total)
    #     print norm, "=norm"
    #     norm_data.append(norm)
    # print norm_data, sum(norm_data)
    plt.hist(norm_data, bins=bins_bound, color='black')
    plt.xlabel('Rate of BAX Oligomerization\n(RFU min^-1)', size=16)
    plt.ylabel('Frequency\n(number of mitochondria)', size=16)
    plt.legend()
    #plt.title('Rate of Aggregation per Mitochondria of One Cell ')
    #plt.ylim(ymax = 2)
    plt.xlim(xmax=1)
    #plt.axes(frameon = False)
    #ax1.get_xaxis().tick_bottom()
    #ax1.get_yaxis().tick_left()
    #plt.rcParams['axes.linewidth'] = 2
    plt.axhline(y=0, linewidth=3, color='black')
    plt.axvline(x=0, linewidth=3, color="black")
    plt.xticks(size=14)
    plt.yticks(size=14)
    plt.minorticks_off()
    plt.tick_params('both', length=8, width=2, which='major')
    plt.show()
Exemple #12
0
def draw_distances(statistics,
                   sample_types,
                   normalize,
                   output_filename,
                   ylim=(2**-3, 2**1)):
    plt.figure(figsize=(8, 5))
    fontsize = 30
    xs = [1000, 3000, 10000, 30000]
    for sample_type_id, sample_type in enumerate(sample_types):
        ys_main_median = []
        ys_main_min = []
        ys_main_max = []
        for x in xs:
            main_distances = statistics[x][sample_type]
            y_median = np.median(main_distances)
            y_min = np.min(main_distances)
            y_max = np.max(main_distances)
            if normalize:
                normalizer = np.mean(statistics[x]["synthetic"])
            else:
                normalizer = 1.0
            ys_main_median.append(y_median / normalizer)
            ys_main_min.append(y_min / normalizer)
            ys_main_max.append(y_max / normalizer)

        markersize_coef = 0.5
        label = sample_type_to_label[sample_type]
        plt.plot(xs,
                 ys_main_median,
                 color=sample_type_to_color[sample_type],
                 marker='o',
                 markersize=fontsize * markersize_coef,
                 label=f"{label}")
        plt.fill_between(xs,
                         ys_main_min,
                         ys_main_max,
                         color=sample_type_to_color[sample_type],
                         linestyle="--",
                         alpha=0.1)

    plt.xlabel("# sequencing reads", fontsize=fontsize)
    plt.ylabel(f"{'Normalized' if normalize else 'Explicit'} JSD",
               fontsize=fontsize)

    plt.xscale("log")

    ax = plt.gca()
    ax.set_xticks(xs)
    ax.get_xaxis().set_major_formatter(mpl.ticker.ScalarFormatter())

    plt.ylim(ylim)

    plt.setp(plt.gca().get_xticklabels(), fontsize=fontsize * 0.8)
    plt.setp(plt.gca().get_yticklabels(), fontsize=fontsize * 0.8)
    plt.minorticks_off()

    plt.tight_layout()

    plt.savefig(output_filename, format="png")
    plt.show()
Exemple #13
0
def plot3_regime(vars1, vars2, vars3, plotname, shem=True, logplot=True, add_ss=True):
    """Plot 3 sets of psi edge loc vs psi max on the same axis for comparison"""
    
    plot_regime(vars1, shem=shem)
    plot_regime(vars2, varcolor='b', shem=shem)
    plot_regime(vars3, varcolor='r', shem=shem)
    
    if add_ss:
        plt.plot(vars_90[0], -1.*vars_90[1], 'sk', ms=10)
        plt.plot(vars_91[0], -1.*vars_91[1], 'sk', ms=10)
        plt.plot(vars_92[0], -1.*vars_92[1], 'sk', ms=10)
        plt.plot(vars_95[0], -1.*vars_95[1], 'sk', ms=10)
        plt.plot(vars_100[0], -1.*vars_100[1], 'sk', ms=10)
        plt.plot(vars_105[0], -1.*vars_105[1], 'sk', ms=10)
    
    plt.xlabel('Cell edge')
    plt.ylabel('Max 500 hPa Mass Streamfunction')
    plt.grid(True,linestyle=':')
    if logplot:
        plt.xscale('log')
        plt.yscale('log')
        plt.minorticks_off()
        plt.xlim(0.625,40)
        plt.ylim(100,600)
        plt.xticks([1.25,2.5,5,10,20,40])
        plt.yticks([75,150,300,600])
        ax=plt.gca()
        ax.get_xaxis().set_major_formatter(tk.ScalarFormatter())
        ax.get_yaxis().set_major_formatter(tk.ScalarFormatter())
        plt.tight_layout()
    else:
        plt.ylim([0,600])
        plt.xlim([0,40])
    plt.savefig('/scratch/rg419/plots/seasons/regimefig_' + plotname +'.pdf', format='pdf')
    plt.close()
def plot_AMI():
    ax = plt.gca()
    ax.autoscale(enable=True, axis='x', tight=True)

    plot_data_at_index(ax=ax,
                       filename='./data/house_ami_no_self.csv',
                       x_idx=0,
                       y_idx=1,
                       ls='-',
                       label='House',
                       regression=True,
                       marker='x')
    plot_data_at_index(ax=ax,
                       filename='./data/senate_ami_no_self.csv',
                       x_idx=0,
                       y_idx=1,
                       ls='-',
                       label='Senate',
                       regression=True,
                       marker='o')

    plot_top_presidents(ax)
    plot_color_bands(ax)
    ax.legend()
    ax.set_xlabel('Congress')
    ax.set_ylabel('AMI')
    ax.set_ylim([0, 1])
    ax.grid()

    plt.minorticks_off()
    plt.savefig('./plots/main_ami_color_no_self',
                bbox_inches='tight',
                pad_inches=0.1)
    plt.show()
def main():

    citation_graph = load_graph(CITATION_URL)

    print compute_in_degrees(citation_graph)


    start_time = timeit.default_timer()

    dist = in_degree_distribution(citation_graph)
    print 'dist =', dist
    total = sum(dist.itervalues())
    normalized = {key: float(value)/total for key, value in dist.items()}
    print(timeit.default_timer() - start_time)

    x = normalized.keys()
    y = normalized.values()
    print len(y)
    plt.loglog(x, y, 'ro')

    plt.yscale('log')
    plt.xscale('log')
    plt.minorticks_off()

    plt.xlabel('In-degree distribution')
    plt.ylabel('Normalized In-degree distribution')
    plt.title('Graph of Citations')
    plt.grid(True)
    plt.savefig('citations-q1.png')
    plt.show()
 def save_image(self, path):
     plt.minorticks_off()
     self.fig.savefig(path, bbox_inches='tight')
     self.fig.savefig(path + '.eps',
                      bbox_inches='tight',
                      format='eps',
                      dpi=600)
Exemple #17
0
def drawdata1(a, b):
    font = {'fontname': 'Arial', 'weight': 'bold', 'size': 15}
    a = np.pi*a
    plt.plot(
        a, b, 'ks', label='LBE', markersize=7, linewidth=2.0)
    a1, b1 = np.polyfit((np.sin(2*a))**2.0, b, 1)
    fit = a1*(np.sin(2*a))**2.0+b1
    plt.plot(a, fit, '-k', label=r'$0.35906\sin(2\theta)^2+0.061074$', linewidth=2.0)
    plt.minorticks_off()
    plt.xlabel(r'$\theta$',
               font, fontsize=20)
    #plt.ylabel(r'$\frac{K}{L^{2}_p}$', font, fontsize=20)
    plt.ylabel(r'$F_2$', font, fontsize=20)
    plt.legend(frameon=False, numpoints=1, loc=9)
    ax = plt.gca()
    setupfunc(ax)
    plt.tick_params(axis='x', which='major', length=5, width=2)
    plt.tick_params(axis='x', which='minor', length=3)
    plt.tick_params(axis='y', which='major', length=5, width=2)
    plt.tick_params(axis='y', which='minor', length=3)
    # ax.spines['top'].set_visible(False)
    # ax.spines['right'].set_visible(False)
    #plt.tick_params(top='off',  right='off')
    savefig(r'4-3permeability.eps', bbox_inches='tight')
    plt.show()
Exemple #18
0
def plot_sv_diagram(x, cn, fusions, outfile, **kwargs):
    """Plots a Campbell-gram with default-y settings.
       Key word arguments are aesthetic options which can be
       safely left blank:
       xmin, xmax, ymin, ymax, xticks, yticks,
       logbase, xlabel, ylabel
    """

    # X axis is in Mb
    x = x / 1e6

    fig = setup_figure()
    cn_axes, fusion_axes = sv_diagram_axes()

    # Copy number

    plot_cn(cn_axes, x, cn)

    set_cn_axes_options(cn_axes, x, cn, kwargs)
    set_cn_axes_aesthetics(cn_axes)
    plt.minorticks_off()

    # Fusions

    setup_fusion_axes(fusion_axes, min(x), max(x))
    for fusion in fusions:
        plot_fusion(cn_axes, fusion_axes, fusion)

    # Ensure everything fits
    plt.tight_layout()

    # Output

    fig.savefig(outfile)
    plt.close(fig)
def plot_auditor_time_vs_stmt_len(plt, expr_dict, num_servers):
    import copy

    num_bits = num_bits_vec[0]
    x = np.array(num_clients_vec)
    y_vals = []
    for count in range(10):
        y = []
        x_new = []
        for i, x_elem in enumerate(x):
            if expr_dict[(num_bits, num_servers, x_elem, count)] is not None:
                print(x_elem, num_servers)
                y.append(expr_dict[(num_bits, num_servers, x_elem,
                                    count)].auditer_avg_time / 10**6)
        y_vals.append(y)

    y_vals = np.array(y_vals)

    errors_bar_y = 1.95 * np.std(y_vals, axis=0) / ((len(y_vals) * 10)**0.5)

    y_vals_avg = np.average(y_vals, axis=0)
    print(y_vals)
    print(errors_bar_y)

    plt.minorticks_off()
    plt.errorbar(
        x,
        y_vals_avg,
        yerr=errors_bar_y,
        # marker=matplotlib.markers.CARETDOWNBASE,
        label=str(num_servers) + " servers",
    )
    def save(self):
        if self.log_path is None:
            return
        ar = np.array(self.buffer)
        logger.info(
            "Minimal action: {}, max action: {}, unique items: {} in {} items".
            format(ar.min(), ar.max(), len(np.unique(ar)), ar.shape))
        with open(self.log_path, self.file_mode) as f:
            w = csv.writer(f)
            for row in self.buffer:
                w.writerow(row)

        item_id, values = list(zip(*self.counter.items()))

        item_id, values = np.array(item_id), np.array(values)
        ind_sort = np.argsort(item_id)
        item_id = item_id[ind_sort]
        values = values[ind_sort]

        plt.hist(item_id, weights=values, bins=100, log=True)
        plt.xlabel("Item ID")
        plt.ylabel("Predictions")
        plt.minorticks_off()
        plt.savefig(self.log_path.parent / "prediction_distribution.png")

        with open(self.log_path.parent / "test_prediction_counter.pkl",
                  "wb") as f:
            pickle.dump(self.counter, f)
        plt.clf()
Exemple #21
0
def loss_boxplot(expt, dataset_name='test1', ax=None):
    # Generate loss data, and set labels
    losses = expt.compute_losses(dataset_name)
    labels = [
        r"$\mathcal{L}_1$", r"$\mathcal{L}_2$", r"$\mathcal{L}_3$",
        r"$\mathcal{L}_4$", r"$\mathcal{L}_5$", r"$\mathcal{L}_6$"
    ]

    # Create a figure or instantiate new axes:
    set_axes(ax)

    # Plot the losses, give the labels
    plt.boxplot(losses,
                labels=labels,
                showfliers=False,
                medianprops={'color': 'black'})

    # Format the Y-Axis
    plt.ylabel("Relative Error")
    plt.ylim([1e-6, 1e-3])
    plt.yscale('log')
    ax = plt.gca()
    ax.set_yticks([1e-6, 1e-5, 1e-4, 1e-3])
    ax.set_yticklabels(
        [r"$10^{-6}$", r"$10^{-5}$", r"$10^{-4}$", r"$10^{-3}$"])
    plt.minorticks_off()
def gen_depthwise():
    gtx_ = np.asarray(gtx[:, 0:2]).transpose()
    tx1_ = np.asarray(tx1[:, 0:2]).transpose()
    tk1_ = np.asarray(tk1[:, 0:2]).transpose()
    raspi_ = np.asarray(raspi[:, 0:2]).transpose()

    out = [gtx_, tx1_, tk1_, raspi_]

    for i in range(len(platform_dd)):
        plt.ylabel('log time per image(ms)')
        plt.yscale('log')
        plt.ylim([0.5, 300 * 10**(i + 1) + 8**(i + 1)])  #manipulating axis
        plt.xlabel('batch size')
        plt.xscale('log')
        plt.xlim([0.5, 256])
        plt.xticks(x_dd, x_dd)
        plt.figtext(.5, .93, platform_dd[i], fontsize=18, ha='center')
        plt.figtext(.5,
                    .9,
                    'mobilenet improvement by depthwise convolution',
                    fontsize=10,
                    ha='center')
        plt.minorticks_off()

        line = plt.plot(x_dd, out[i][0], '--o', label='mobilenet')
        line1 = plt.plot(x_dd, out[i][1], '--o', label='mobilenet depthwise')

        plt.legend()
        #plt.show()
        plt.savefig('mobilenet_' + platform_dd[i] + '.png',
                    bbox_inches='tight')
        plt.clf()
        plt.close()
Exemple #23
0
def plot1d(func, lb, ub, step, stop_val=None, stop_iter=50, svname='', show=False, esp=1e-7, adaptive=False):
    x = np.arange(lb, ub, step)
    prog = Progress(len(x), label='plotting', response_time=60)
    if adaptive:
        y = []
        stop_cnt = 0
        for xval in x:
            prog.count()
            yval = func(xval)
            y.append(yval)
            if abs(yval - stop_val) < esp:
                stop_cnt += 1
                if stop_cnt > stop_iter:
                    break
            else:
                stop_cnt = 0
        x = x[:len(y)]
    else:
        y = fp.lmap(func, x)

    fig = plt.figure(1)
    plt.minorticks_off()
    plt.plot(x, y, 'k', color='b')
    if svname != '':
        plt.savefig(svname)
    if show:
        plt.show()
    plt.close(fig)

    return len(x)
Exemple #24
0
def plot_latency_vary_size(exp_idxs, labels, tx, sizes, rp, num_of_server, tag, fig_num):
    assert len(exp_idxs) == len(labels)
    alo_lists = [get_latency_vary_size(idx, tx, sizes, rp, tag) for idx in exp_idxs]

    fig, axs = plt.subplots(figsize=fig_size)

    for j, alo_list in enumerate(alo_lists):
        axs.plot(sizes, alo_list, colors[j], marker=markers[j], label=labels[j],
                 linestyle=linestyle, linewidth=linewidth, markersize=markersize)

    axs.legend(loc='upper left', ncol=legend_ncol, prop=legend_prop)  ##
    axs.set_xlabel(vary_szs_x_label(num_of_server, tx, rp), fontsize=fontsize)
    plt.xscale('log')
    plt.xticks(sizes, tuple(sizes))
    plt.minorticks_off()
    # plt.yticks(np.arange(0, 2500, step=500))
    # plt.yticks(np.arange(0, 4500, step=500))
    plt.yticks(np.arange(0, 6500, step=500))
    tag = ' '.join(tag.split("_"))
    axs.set_ylabel(f"{tag} latency (µs)", fontsize=fontsize)

    plt.grid(color='tab:gray', linestyle=':', linewidth=0.8)
    plt.tight_layout()
    tag = '_'.join(tag.split(" "))
    plt.savefig(f"LAN_{fig_num}_latency,_vary_size,_{num_of_server}_svrs,_{tag}")
    plt.show()
def metrics_progress_plot(df,
                          path,
                          sliding_window=5,
                          y="Return",
                          df_type="train"):
    fig = plt.figure(figsize=[6.4, 4.8])
    df = df[df.Epoch >= 20]
    rolling_metric = df.groupby(
        ["Method", "Seed",
         "Dataset"])[y].apply(lambda x: x.ewm(span=sliding_window).mean())
    df.loc[:, y] = rolling_metric

    df.Epoch = df.Epoch // 89
    print(df.iloc[0])
    ax = sns.lineplot(x="Epoch", y=y, seed=16, hue="Method", data=df)
    plt.xlabel("Iteration")
    handles, labels = ax.get_legend_handles_labels()
    try:
        index_of = labels.index("Method")
        handles.pop(index_of)
        labels.pop(index_of)
    except ValueError:
        pass
    ax.legend_.remove()
    # sort both labels and handles by labels
    labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))
    ax.legend(handles, labels)  # , bbox_to_anchor=(1,0.7))
    plt.minorticks_off()
    plt.tight_layout()
    save_plot(path, "{}_{}".format(df_type, y.lower()))
Exemple #26
0
    def plot_temps(self):
        """
        Plot NAND temps vs Ambient Temp
        :return:
        """

        self._get_max_bw()

        try:
            plot_df = self.comb_df[[
                "Drive Temperature.1", "Drive Temperature.2",
                "Drive Temperature.3", "Drive Temperature.4", "Ambient"
            ]].copy()
            cols_to_plot = [
                "Drive Temperature.1", "Drive Temperature.2",
                "Drive Temperature.3", "Drive Temperature.4", "Ambient"
            ]
        except KeyError as e:
            logging.warning(
                "KeyError {}, trying other configuration.".format(e))
            plot_df = self.comb_df[[
                "Drive Temperature", "Drive Temperature.1",
                "Drive Temperature.2", "Drive Temperature.3", "Ambient"
            ]].copy()
            cols_to_plot = [
                "Drive Temperature", "Drive Temperature.1",
                "Drive Temperature.2", "Drive Temperature.3", "Ambient"
            ]

        # Drop all rows that have an NaN value
        plot_df = plot_df.dropna(axis=0, how="any")

        plot_df = plot_df.drop_duplicates()

        fig, ax1 = plt.subplots(figsize=self.figsize)

        # plot all columns in cols_to_plot
        for col in cols_to_plot:
            ax1.plot(plot_df.index, plot_df[col], label=col)
            # ax1.scatter(plot_df.index, plot_df[col], label = col)

        plt.minorticks_off()
        plt.tick_params(axis='x', which='minor', bottom=False)

        plt.grid(axis='y')
        # Set y axis ticks at every 1 degree
        ax1.yaxis.set_major_locator(ticker.MultipleLocator(1))

        ax1.set_ylabel("Temperature (C)")

        ax1.legend()

        plt.title("Drive Temperature vs Ambient Temperature")

        save_path = os.path.join(self.dirpath, "Drive_Temp_vs_Ambient.png")

        self.log_q.put("Saving Drive_Temp_vs_Ambient at {}".format(save_path))
        logging.info("Saving drive_temp_vs_ambient at {}".format(save_path))
        plt.savefig(save_path, dpi='figure')
Exemple #27
0
def grid(b=True, which="major"):
    # This is consistent with `ideplot.grid`, not with `matplotlib.pyplot.grid`.
    if which in ["minor", "both"]:
        if b:
            plt.minorticks_on()
        else:
            plt.minorticks_off()
    plt.grid(b, which)
Exemple #28
0
def bins_labels(bins, **kwargs):
    """
    Center bins for histogram (see: https://stackoverflow.com/a/42264525/1679629)
    """
    bin_w = (max(bins) - min(bins)) / (len(bins) - 1)
    plt.xticks(numpy.arange(min(bins) + bin_w / 2, max(bins) + 1, bin_w), bins, **kwargs)
    plt.xlim(bins[0], bins[-1])
    plt.minorticks_off()
def make_plot(show=False):
    # Set up figure
    fig = plot.figure(figsize=(10, 6), dpi=dpi)
    ax = fig.add_subplot(111)

    ### Plot ###
    x = radii
    y = freq
    result = plot.pcolormesh(x, y, np.abs(fft_data), cmap=cmap)
    result.set_clim(clim)
    plot.colorbar()

    # Reference Line
    xref = radii
    yref1 = np.power(radii, -1.5) * (np.sqrt(5) - 2.0)
    yref2 = np.power(radii, -1.5)
    ref_color = "deepskyblue"
    plot.plot(xref, yref1, c=ref_color, linewidth=2, linestyle="--")
    plot.plot(xref, yref2, c=ref_color, linewidth=2)

    # Axes
    plot.xlim(radii[0], radii[-1])
    plot.ylim(min(freq[freq > 0]), max(freq))
    plot.xscale("log")
    plot.yscale("log")

    xticks = np.concatenate(
        (np.logspace(np.log10(0.5), np.log10(1.0),
                     3), np.logspace(np.log10(1.0), np.log10(2.5), 5)[1:]))
    plot.minorticks_off(
    )  # Fixes known bug where xticks aren't removed if scale is log
    plot.xticks(xticks, ['%.2f' % xtick for xtick in xticks])

    yticks = np.logspace(np.log10(1.0 * cadence / len(frames) / rate),
                         np.log10(0.5 * cadence / rate), 10)
    plot.yticks(yticks, ['%.3f' % ytick for ytick in yticks])

    # Annotate Axes
    radius_unit = r'$r_\mathrm{p}$'
    plot.xlabel("Radius [%s]" % radius_unit, fontsize=fontsize)
    plot.ylabel(r"$\omega / \Omega_\mathrm{0}$", fontsize=fontsize)

    # Save, Show, and Close
    directory_name = os.getcwd().split("/")[-1]

    if version is None:
        save_fn = "%s/%s_FFTverticalVelocityMap_%04d_%04d_%04d.png" % (
            save_directory, directory_name, frames[0], frames[-1], args.rate)
    else:
        save_fn = "%s/v%04d_%s_FFTverticalVelocityMap_%04d_%04d_%04d.png" % (
            save_directory, version, directory_name, frames[0], frames[-1],
            args.rate)
    plot.savefig(save_fn, bbox_inches='tight', dpi=dpi, pad_inches=0.2)

    if show:
        plot.show()

    plot.close(fig)  # Close Figure (to avoid too many figures)
def plot_curve(filename):
    with open(filename) as csvfile:
        r = csv.DictReader(csvfile)

        layers = []
        #errors_49 = []
        errors_68 = []

        for row in r:
            _layers = row["layers"].replace("[", "").replace("]", "")
            if "," in _layers:
                continue
            neurons = int(_layers)
            if neurons < 48:
                continue
            #if neurons not in [2**i for i in range(12)]:
            #    continue
            layers.append(neurons)
            #errors_49.append(float(row["test_error_49"]))
            #errors_68.append(float(row["test_error_68"]))
            errors_68.append(
                (float(row["best_e68"]) + float(row["best_h68"])) / 2)

    combined = list(zip(layers, errors_68))
    combined = sorted(combined, key=lambda x: x[0])

    layers = [x[0] for x in combined]
    #errors_49 = [x[1] for x in combined]
    errors_68 = [x[1] for x in combined]

    ax = plt.gca()
    #ax.set_aspect(2)

    plt.xticks([1, 32, 64, 128, 192, 256, 384, 512], rotation=0)
    ax.set_yscale("log", basey=10)
    ax.set_yticks([
        min(errors_68), 0.2, 0.4, 0.6, 0.8, 1.0, 1.5, 2.0, 2.5, 3.0,
        max(errors_68)
    ])
    plt.minorticks_off()
    #plt.grid()

    ax.xaxis.set_minor_formatter(mticker.ScalarFormatter())
    #ax.yaxis.set_minor_formatter(mticker.ScalarFormatter())
    ax.yaxis.set_major_formatter(mticker.ScalarFormatter())

    #plt.plot(layers, errors_49, '--ro', label="test error (49 landmarks)")
    plt.plot(layers, errors_68, '--bo', label="test error (68 landmarks)")

    #plt.legend()
    #plt.subplots_adjust(bottom=0.15)

    plt.xlabel("latent vector dimension")
    plt.ylabel("IOD normalized RMSE in % (log scale)")
    #plt.savefig("/tmp/pdm_reconstruction_error.png", bbox_inches='tight')
    plt.show()
    plt.clf()
Exemple #31
0
async def gen_plot(ctx, tmf: typing.Optional[str] = '24'):
    user_range = 0
    if tmf.lower() in ['w', 'week', 'weeks']:
        user_range = 168 - 1
        interval = 24
        date_format = '%m/%d'
        timedo = 'week'
        description = 'Players online in the past ' + timedo + ':'
    elif tmf.lower() in ['12', '12hrs', '12h', '12hr']:
        user_range = 12 - 0.15
        interval = 1
        date_format = '%H'
        timedo = '12hrs'
        description = 'Players online in the past ' + timedo + ':'
    else:
        user_range = 24 - 0.30
        interval = 2
        date_format = '%H'
        timedo = '24hrs'
        description = 'Players online in the past ' + timedo + ':'

    #Get data from csv
    df = pd.read_csv('csv/playerstats.csv', header=None, usecols=[0, 1], parse_dates=[0], dayfirst=True)
    lastday = datetime.now() - timedelta(hours = user_range)
    last24 = df[df[0]>=(lastday)]

    # Plot formatting / styling matplotlib
    plt.style.use('seaborn-pastel')
    plt.minorticks_off()
    fig, ax = plt.subplots()
    ax.grid(b=True, alpha=0.2)
    ax.set_xlim(lastday, datetime.now())
    # ax.set_ylim(0, 10) Not sure about this one yet
    for axis in [ax.xaxis, ax.yaxis]:
        axis.set_major_locator(ticker.MaxNLocator(integer=True))
    ax.xaxis.set_major_formatter(md.DateFormatter(date_format))
    ax.xaxis.set_major_locator(md.HourLocator(interval=interval))
    for spine in ax.spines.values():
        spine.set_visible(False)
    for tick in ax.get_xticklabels():
        tick.set_color('gray')
    for tick in ax.get_yticklabels():
        tick.set_color('gray')
    
    #Plot and rasterize figure
    plt.gcf().set_size_inches([5.5,3.0])
    plt.plot(last24[0], last24[1])
    plt.tick_params(axis='both', which='both', bottom=False, left=False)
    plt.margins(x=0,y=0,tight=True)
    plt.tight_layout()
    fig.savefig('temp.png', transparent=True, pad_inches=0) # Save and upload Plot
    image = discord.File('temp.png', filename='temp.png')
    plt.close()
    embed = discord.Embed(title=server_name, description=description, colour=12320855)
    embed.set_image(url='attachment://temp.png')
    await ctx.send(file=image, embed=embed)
Exemple #32
0
def main():
    # plot cost
    ticks_x, costmatrix = generate_costlist(total_torsions=20)

    print("t r")
    for x, y in zip(ticks_x, costmatrix):
        print(*x, y)

    ticks_x = ["{:},{:}".format(*x) for x in ticks_x]
    ticks_x = np.asarray(ticks_x)
    xticks = list(range(len(ticks_x)))
    xticks = np.asarray(xticks)

    max_cost = 10**7

    idx = np.where(costmatrix < max_cost)

    ticks_x = ticks_x[idx]
    xticks = xticks[idx]
    costmatrix = costmatrix[idx]

    plt.figure(figsize=(15, 5))
    plt.plot(costmatrix,
             'k.-',
             markersize=10,
             markeredgewidth=1.5,
             markeredgecolor='w')
    plt.xticks(xticks, ticks_x, rotation=-45)
    plt.xlabel("(Torsions, Clockwork)")
    plt.yscale("log")
    plt.grid(True, axis="y", color="k")

    ax = plt.gca()

    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.spines['bottom'].set_visible(True)
    ax.spines['left'].set_visible(False)

    # Add extra lines
    for total_torsions in [10, 30, 40, 50, 60, 70]:
        print("add extra")
        ticks_x, costmatrix = generate_costlist(total_torsions=total_torsions)
        idx = np.where(costmatrix < max_cost)
        costmatrix = costmatrix[idx]
        plt.plot(costmatrix,
                 '.-',
                 markersize=10,
                 markeredgewidth=1.5,
                 markeredgecolor='w')

    plt.minorticks_off()
    plt.savefig("linearcost", bbox_inches="tight")

    plt.clf()
def relative_plotmaker(com1, com2, drugname, sec_analysed, tp_analysed,
                       savename):
    # make copy for safety
    cp1 = com1.copy(deep=True)
    cp2 = com2.copy(deep=True)

    # concatenate all absolute dataframe copies
    df = pd.concat([cp1, cp2]).set_index(np.arange(1, 3))
    # make all 0s NaN
    rel_com = df.replace(to_replace=0, value=np.nan)
    # x axis values
    timepoints = np.arange(1, 3)

    f, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2,
                                               2,
                                               sharex=True,
                                               sharey='all',
                                               figsize=(12, 8))
    plt.suptitle('Average change for ' + drugname + ' relative to DMSO',
                 fontsize='x-large')
    plt.subplots_adjust(wspace=0.2, hspace=0.2, top=0.87)
    plt.minorticks_off()
    plt.xticks(timepoints, ('7', '20'))
    plt.margins(0.1, 0.1)
    ax = [ax1, ax2, ax3, ax4]
    for i in ax:
        i.tick_params(top='off', right='off')

    # fills in subplots for relative
    ax1.plot(timepoints, rel_com['gr L 1'], color='brown', label='gr')
    ax1.plot(timepoints, rel_com['het L 1'], color='k', label='het')
    ax1.set_title('Incubation Time 1h', fontsize=10)
    ax1.set_ylabel('Light, Distance (mm)')

    ax2.plot(timepoints, rel_com['gr L 24'], color='brown', label='gr')
    ax2.plot(timepoints, rel_com['het L 24'], color='k', label='het')
    ax2.set_title('Incubation Time 24h', fontsize=10)
    ax2.legend(loc=5,
               fontsize='x-small',
               bbox_to_anchor=(1.4, 0.3),
               borderaxespad=0,
               title=(sec_analysed + ' sec, tp ' + tp_analysed))

    ax3.plot(timepoints, rel_com['gr D 1'], color='brown', label='gr')
    ax3.plot(timepoints, rel_com['het D 1'], color='k', label='het')
    ax3.set_ylabel('Speed (mm/s)')
    ax3.set_xlabel('Concentration (uM)')
    ax3.set_ylabel('Dark, Distance (mm)')

    ax4.plot(timepoints, rel_com['gr D 24'], color='brown', label='gr')
    ax4.plot(timepoints, rel_com['het D 24'], color='k', label='het')
    ax4.set_xlabel('Concentration (uM)')

    f.savefig(savename, bbox_inches='tight')
    plt.close('all')
def figplot(clrs, x, y, xlab, ylab, fig, n):

    fig.add_subplot(2, 2, n)
    plt.xscale('log')
    if n == 1: plt.yscale('log', subsy=[1, 2])
    plt.yscale('log')
    plt.minorticks_off()

    d = pd.DataFrame({'x': np.log10(x)})
    d['y'] = np.log10(y)
    f = smf.ols('y ~ x', d).fit()

    m, b, r, p, std_err = stats.linregress(np.log10(x), np.log10(y))
    st, data, ss2 = summary_table(f, alpha=0.05)
    fitted = data[:, 2]
    mean_ci_low, mean_ci_upp = data[:, 4:6].T
    ci_low, ci_upp = data[:, 6:8].T

    x, y, fitted, ci_low, ci_upp, clrs = zip(
        *sorted(zip(x, y, fitted, ci_low, ci_upp, clrs)))

    x = np.array(x)
    y = np.array(y)
    fitted = 10**np.array(fitted)
    ci_low = 10**np.array(ci_low)
    ci_upp = 10**np.array(ci_upp)

    if n == 1:
        lbl = r'$rarity$' + ' = ' + str(round(
            10**b, 1)) + '*' + r'$N$' + '$^{' + str(round(m, 2)) + '}$'
    elif n == 2:
        lbl = r'$Nmax$' + ' = ' + str(round(
            10**b, 1)) + '*' + r'$N$' + '$^{' + str(round(m, 2)) + '}$'
    elif n == 3:
        lbl = r'$Ev$' + ' = ' + str(round(
            10**b, 1)) + '*' + r'$N$' + '$^{' + str(round(m, 2)) + '}$'
    elif n == 4:
        lbl = r'$S$' + ' = ' + str(round(
            10**b, 1)) + '*' + r'$N$' + '$^{' + str(round(m, 2)) + '}$'

    plt.scatter(x, y, s=sz, color=clrs, linewidths=0.0, edgecolor=None)
    plt.fill_between(x, ci_upp, ci_low, color='0.5', lw=0.1, alpha=0.2)
    plt.plot(x, fitted, color='k', ls='--', lw=0.5, label=lbl)

    if n == 3: plt.legend(loc=3, fontsize=8, frameon=False)
    else: plt.legend(loc=2, fontsize=8, frameon=False)

    plt.xlabel(xlab, fontsize=10)
    plt.ylabel(ylab, fontsize=10)
    plt.tick_params(axis='both', labelsize=6)
    if n in [2, 4]: plt.ylim(min(y), max(y))
    elif n == 1: plt.ylim(min(ci_low), max(ci_upp))
    elif n == 3: plt.ylim(0.1, 1.1)

    return fig
Exemple #35
0
def saveBitmap(outputFileName, inputFileName, imageData, size, colorMapName, caption):
    """Makes a bitmap image from an image array; the image format is specified by the
    filename extension. (e.g. ".jpg" =JPEG, ".png"=PNG).
    
    @type outputFileName: string
    @param outputFileName: filename of output bitmap image
    @type imageData: numpy array
    @param imageData: image data array
    @type cutLevels: list
    @param cutLevels: sets the image scaling - available options:
        - pixel values: cutLevels=[low value, high value].
        - histogram equalisation: cutLevels=["histEq", number of bins ( e.g. 1024)]
        - relative: cutLevels=["relative", cut per cent level (e.g. 99.5)]
        - smart: cutLevels=["smart", cut per cent level (e.g. 99.5)]
    ["smart", 99.5] seems to provide good scaling over a range of different images. 
    @type size: int
    @param size: size of output image in pixels
    @type colorMapName: string
    @param colorMapName: name of a standard matplotlib colormap, e.g. "hot", "cool", "gray"
    etc. (do "help(pylab.colormaps)" in the Python interpreter to see available options)
    
    """
    import time
    start = time.time()
    scale=zscale.zscale(imageData)
    anorm = matplotlib.colors.Normalize(scale[0],scale[1])
    cut = {'image': imageData, 'norm': anorm}  
    # Make plot
    aspectR=float(cut['image'].shape[0])/float(cut['image'].shape[1])
    fig = pyplot.figure(figsize=(10,10*aspectR))

    xPix = size
    yPix = size
    dpi = 80
    xSizeInches = size/dpi
    ySizeInches = xSizeInches
    fig.set_size_inches(xSizeInches,ySizeInches)
    pyplot.axes([0,0,1,1])
    pyplot.minorticks_off()	
        
    try:
        colorMap=matplotlib.cm.get_cmap(colorMapName)
    except AssertionError:
        raise Exception, colorMapName+" is not a defined matplotlib colormap."

    pyplot.imshow(cut['image'],  interpolation="bilinear",  norm=cut['norm'], origin='lower', cmap=colorMap)
    pyplot.axis("off")
    xmin,xmax = fig.gca().get_xlim()
    ymin,ymax = fig.gca().get_ylim()
    pyplot.text(xmin+1,ymin+35,caption,color="red",fontsize=20,fontweight=500,backgroundcolor='white')

    pyplot.savefig(outputFileName,format="png",dpi=dpi)
    pyplot.close()
    return inputFileName,outputFileName
def figplot(clrs, x, y, xlab, ylab, fig, n):

    fig.add_subplot(2, 2, n)
    plt.xscale('log')
    if n == 1: plt.yscale('log', subsy=[1, 2])
    plt.yscale('log')
    plt.minorticks_off()

    d = pd.DataFrame({'x': np.log10(x)})
    d['y'] = np.log10(y)
    f = smf.ols('y ~ x', d).fit()

    m, b, r, p, std_err = stats.linregress(np.log10(x), np.log10(y))
    st, data, ss2 = summary_table(f, alpha=0.05)
    fitted = data[:,2]
    mean_ci_low, mean_ci_upp = data[:,4:6].T
    ci_low, ci_upp = data[:,6:8].T

    x, y, fitted, ci_low, ci_upp, clrs = zip(*sorted(zip(x, y, fitted, ci_low, ci_upp, clrs)))

    x = np.array(x)
    y = np.array(y)
    fitted = 10**np.array(fitted)
    ci_low = 10**np.array(ci_low)
    ci_upp = 10**np.array(ci_upp)

    if n == 1: lbl = r'$rarity$'+ ' = '+str(round(10**b,1))+'*'+r'$N$'+'$^{'+str(round(m,2))+'}$'
    elif n == 2: lbl = r'$Nmax$'+ ' = '+str(round(10**b,1))+'*'+r'$N$'+'$^{'+str(round(m,2))+'}$'
    elif n == 3: lbl = r'$Ev$'+ ' = '+str(round(10**b,1))+'*'+r'$N$'+'$^{'+str(round(m,2))+'}$'
    elif n == 4: lbl = r'$S$'+ ' = '+str(round(10**b,1))+'*'+r'$N$'+'$^{'+str(round(m,2))+'}$'

    plt.scatter(x, y, s = sz, color=clrs, linewidths=0.0, edgecolor=None)
    plt.fill_between(x, ci_upp, ci_low, color='0.5', lw=0.1, alpha=0.2)
    plt.plot(x, fitted,  color='k', ls='--', lw=0.5, label = lbl)

    if n == 3: plt.legend(loc=3, fontsize=8, frameon=False)
    else: plt.legend(loc=2, fontsize=8, frameon=False)

    plt.xlabel(xlab, fontsize=10)
    plt.ylabel(ylab, fontsize=10)
    plt.tick_params(axis='both', labelsize=6)
    if n in [2, 4]: plt.ylim(min(y), max(y))
    elif n == 1: plt.ylim(min(ci_low), max(ci_upp))
    elif n == 3: plt.ylim(0.1, 1.1)

    return fig
Exemple #37
0
def hists(df, keys=['m1'], nbins=100):
    print 'fits from {0} bootstraps'.format(df['bi'].max())
    fig = plt.figure()
    # ax = plt.gca()
    axs = [fig.add_subplot(2, 1, i+1) for i in range(2)] # for each dotmode
    clrs = [[0.0, 0.7, 0.0], [0.7, 0.0, 0.0]]
    # bins = np.linspace(df[keys].min().min(), df[keys].max().max(), nbins)
    bins = np.linspace(0.0, 1.0, nbins)
    ymx = 10.0
    for i, (dotmode, dfc) in enumerate(df.groupby('dotmode', as_index=False)):
        for key in keys:
            dfc[key].hist(bins=bins, alpha=1.0, normed=True, color=clrs[i], histtype='stepfilled', lw=2, ax=axs[i])
            # dfc[key].hist(bins=bins, alpha=1.0, normed=True, color=clrs[i], histtype='step', ax=axs[i])
        axs[i].set_xlim(min(bins), max(bins))
        axs[i].set_ylim(0.0, ymx)
        axs[i].grid(False)
        axs[i].plot([0.3, 0.3], [0.0, ymx], '--k', lw=3, alpha=0.4, label='probability summation')
        axs[i].plot([0.5, 0.5], [0.0, ymx], '-k', lw=3, alpha=0.4, label='perfect integration')
        # axs[i].plot([0.3, 0.3], [0.0, ymx], ':k', lw=2, label='probability summation')
        # axs[i].plot([0.5, 0.5], [0.0, ymx], '--k', lw=2, label='perfect integration')

    leg = axs[-1].legend(loc='lower right', prop={'size': 14})
    leg.get_frame().set_linewidth(1.5)
    axs[-1].invert_yaxis()
    plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.0, hspace=0.0)

    plt.minorticks_off()
    axs[-1].tick_params(top='off')
    axs[-1].tick_params(right='off')
    axs[-1].tick_params(axis='x', direction='out', width=1.5, length=5)
    axs[-1].tick_params(axis='y', direction='out', width=1.5, length=5)
    axs[-1].patch.set_facecolor('white')
    for axis in ['bottom', 'left']:
        axs[-1].spines[axis].set_linewidth(lw)
    for axis in ['top', 'right']:
        axs[-1].spines[axis].set_linewidth(0)
    axs[0].tick_params(top='off')
    axs[0].tick_params(right='off')
    axs[0].tick_params(axis='x', direction='out', width=1.5, length=5)
    axs[0].tick_params(axis='y', direction='out', width=1.5, length=5)
    axs[0].patch.set_facecolor('white')
    for axis in ['bottom', 'left']:
        axs[0].spines[axis].set_linewidth(lw)
    for axis in ['top', 'right']:
        axs[0].spines[axis].set_linewidth(0)
    plt.show()
Exemple #38
0
    def stem_event_count(self, stream):
        key = (stream.room, stream.sid, stream.typo)
        interval = stream._interval
        stream.set_interval(interval)

        yres = stream.apply_func(lambda i, v: len(v))
        xres = stream.get_intervals()

        fig = plt.figure()
        ax = fig.add_subplot(111, axisbg='#F8F8F8')

        markerline, stemlines, baseline = ax.stem(xres, yres)
        plt.xticks(rotation=50)
        plt.title('Number of events produced ' + _key_to_title(
            key), fontdict=self._override)
        plt.yticks(fontsize=16)
        plt.xticks(fontsize=11)
        ax.yaxis.labelpad = 18
        ax.xaxis.labelpad = 18

        plt.ylabel('Number of events', fontdict=self._override)

        if isinstance(interval, off.Day):
            delta = timedelta(days=1)
            ax.xaxis.set_major_locator(mpd.DayLocator(interval=1))
            ax.xaxis.set_major_formatter(mpd.DateFormatter('%d/%m'))
        elif isinstance(interval, off.Hour):
            delta = timedelta(hours=1)
            ax.xaxis.set_major_locator(mpd.HourLocator(interval=3))
            ax.xaxis.set_major_formatter(mpd.DateFormatter('%d/%m %H:%M'))
        elif isinstance(interval, off.Minute):
            delta = timedelta(hours=1)
            ax.xaxis.set_major_locator(mpd.HourLocator(interval=20))
            ax.xaxis.set_major_formatter(mpd.DateFormatter('%d/%m %H:%M'))
        else:
            raise ValueError('Interval type is unmanageable')

        ax.set_xlim(xres[0] - delta, xres[-1] + delta)
        miny = min(yres)
        maxy = max(yres)
        ax.set_ylim(0.9 * miny, 1.1 * maxy)

        plt.minorticks_off()
        #ax.set_aspect('0.04')
        self._save_current_figure(fig, suffix='_count')
Exemple #39
0
def set_cn_axes_options(cn_axes, x, cn, kwargs):
    """Sets various options for the CN axes, including labels,
       whether to log-transform the y-axis, etc. Could add zebra
       stripe options ..."""
    # xmin, xmax, ymin, ymax, xticks, yticks, xlabel, ylabel

    if kwargs.get("logbase", None) != None:
        cn_axes.set_yscale("log", basey=kwargs["logbase"])
        cn_axes.yaxis.set_major_formatter(ScalarFormatter())
        plt.minorticks_off()

    if (kwargs.get("xmin", None) != None) and (kwargs.get("xmax", None) != None):
        cn_axes.set_xlim(kwargs["xmin"], kwargs["xmax"])
        cn_axes.spines["bottom"].set_bounds(kwargs["xmin"], kwargs["xmax"])
    else:
        cn_axes.set_xlim(min(x), max(x))
        cn_axes.spines["bottom"].set_bounds(min(x), max(x))

    if kwargs.get("ymin", None) != None:
        cn_axes.set_ylim(bottom=kwargs["ymin"])

    if kwargs.get("ymax", None) != None:
        cn_axes.set_ylim(top=kwargs["ymax"])

    if kwargs.get("xticks", None) != None:
        cn_axes.set_xticks(kwargs["xticks"])
        cn_axes.set_xticklabels(kwargs["xticks"])

    if kwargs.get("yticks", None) != None:
        yticks = kwargs["yticks"]
        cn_axes.set_yticks(yticks)
        cn_axes.set_yticklabels(yticks)
        cn_axes.spines["left"].set_bounds(min(yticks), max(yticks))

    if kwargs.get("xlabel", None) != None:
        cn_axes.set_xlabel(kwargs["xlabel"])
    else:
        cn_axes.set_xlabel("Position on chromosome ?? (Mb)")

    if kwargs.get("ylabel", None) != None:
        cn_axes.set_ylabel(kwargs["ylabel"])
    else:
        cn_axes.set_ylabel("Estimated copy number")
def displayData(X, nrows=10, ncols=10):
    # set up array
    fig, axarr = plt.subplots(nrows=nrows, ncols=ncols,
                              figsize=(nrows, ncols))

    nblock = int(np.sqrt(X.shape[1]))

    # loop over randomly drawn numbers
    ct = 0
    for ii in range(nrows):
        for jj in range(ncols):
            # ind = np.random.randint(X.shape[0])
            tmp = X[ct, :].reshape(nblock, nblock, order='F')
            axarr[ii, jj].imshow(tmp, cmap='gray')
            plt.setp(axarr[ii, jj].get_xticklabels(), visible=False)
            plt.setp(axarr[ii, jj].get_yticklabels(), visible=False)
            plt.minorticks_off()
            ct += 1

    fig.subplots_adjust(hspace=0, wspace=0)
Exemple #41
0
def PlotDET(results, eerDcf, title):
    """
    Plots a DET curve with false positive and false negative rates (results).
    marks minDCF value (from eerDcf) for each curve.
    Some code based on https://jeremykarnowski.wordpress.com/2015/08/07/detection-error-tradeoff-det-curves/
    """
    axis_min = min(min(results))
    fig,ax = plt.subplots()
    for r in range(len(results)):
        plt.plot(results[r][0], results[r][1], linewidth = 2, label = results[r][2])
        if r == len(results)-1:
            plt.plot(eerDcf[r][2][0], eerDcf[r][2][1], 'kD', markersize=6, label = "DCF minimipisteet")
        else:
            plt.plot(eerDcf[r][2][0], eerDcf[r][2][1], 'kD', markersize=6)
    plt.yscale('logit')
    plt.xscale('logit')
    majorTicks = [0.01,0.02,0.05,0.1,0.2,0.4,0.6,0.8,0.9]
    ax.xaxis.set_major_formatter(ScalarFormatter())
    ax.yaxis.set_major_formatter(ScalarFormatter())
    ax.set_xticks(majorTicks)
    ax.set_yticks(majorTicks)
    plt.axis([0.005,0.9,0.005,0.9])
    plt.title(title)
    plt.xlabel(u"Väärät hyväksymiset (%)")
    plt.ylabel(u"Väärät hylkäykset (%)")
    plt.legend(loc = 0)
    plt.minorticks_off()
    
    def ToPercent(y, position):
        return int(y * 100)
        
    formatter = FuncFormatter(ToPercent)
    plt.gca().yaxis.set_major_formatter(formatter)
    plt.gca().xaxis.set_major_formatter(formatter)
    ax.grid(True)
    plt.show()
Exemple #42
0
def plot_svd_components(tup, n=4, from_t = None):
    wl, t, d = tup.wl, tup.t, tup.data
    if from_t:
        idx = dv.fi(t, from_t)
        t = t[idx:]
        d = d[idx:, :]
    u, s, v = np.linalg.svd(d)
    ax1: plt.Axes = plt.subplot(311)
    ax1.set_xlim(-1, t.max())


    lbl_trans()
    plt.minorticks_off()
    ax1.set_xscale('symlog')
    ax2 = plt.subplot(312)
    lbl_spec()
    plt.ylabel('')
    for i in range(n):
        ax1.plot(t,u.T[i], label=str(i) )
        ax2.plot(wl,v[i] )
    ax1.legend()
    plt.subplot(313)
    plot_singular_values(d)
    plt.tight_layout()
Exemple #43
0
def plotEigPowerRec(angFreq, eigValGen, powerSample, powerRec, powerAna=None,
                    eigAna=None,
                    markersize=None, condition=None,
                    xlabel=None, ylabel=None, zlabel=None,
                    xlim=None, ylim=None, zlim=None,
                    xticks=None, yticks=None, zticks=None):
    if condition is None:
        condition = 'b'
    # Create axis for eigenvalue and power spectrum panels
    nullfmt = plt.NullFormatter()
    left, width = 0.1, 0.6
    bottom, height = 0.1, 0.9
    leftPow = left + width + 0.01
    widthPow = 0.25
    rectEig = [left, bottom, width, height]
    rectPow = [leftPow, bottom, widthPow, height]
    ratio = height / width
    defaultFigHeight = plt.rcParams['figure.figsize'][1]
    fig = plt.figure(figsize=(defaultFigHeight*ratio, defaultFigHeight))
    axEig = plt.axes(rectEig)
    axPow = plt.axes(rectPow)

    # Plot eigenvalues
    if markersize is not None:
        axEig.scatter(eigValGen.real, eigValGen.imag,
                      s=msize*2, marker='+',
                      c=condition, cmap=cm.Greys_r)
    else:
        markersize=20

    axEig.scatter(eigValGen.real, eigValGen.imag,
                  s=markersize, marker='o', edgecolors='face',
                  c=condition, cmap=cm.Greys_r)
    if eigAna is not None:
        axEig.scatter(eigAna.real, eigAna.imag, c='k',
                      s=int(markersize*2.), marker='x')
    if xlim is not None:
        axEig.set_xlim(xlim)
    if ylim is not None:
        axEig.set_ylim(ylim)
    axEig.set_xlabel(xlabel, fontsize=fs_default)
    axEig.set_ylabel(ylabel, fontsize=fs_default)
    if xticks is not None:
        axEig.set_xticks(xticks)
    if yticks is not None:
        axEig.set_yticks(yticks)
    plt.setp(axEig.get_xticklabels(), fontsize=fs_xticklabels)
    plt.setp(axEig.get_yticklabels(), fontsize=fs_yticklabels)
    axEig.grid()

    # Plot power spectra
    axPow.plot(powerSample, angFreq, 'k-')
    if powerAna is not None:
        axPow.plot(powerAna, angFreq, 'b-')
    axPow.plot(powerRec, angFreq, '--r', linewidth=2)
    axPow.set_xscale('log')
    if zlim is not None:
        axPow.set_xlim(zlim)
    if ylim is not None:
        axPow.set_ylim(ylim)
    axPow.set_xlabel(zlabel, fontsize=fs_default)
    axPow.yaxis.set_major_formatter(nullfmt)
    if yticks is not None:
        axPow.set_yticks(yticks)
    if zticks is not None:
        axPow.set_xticks(zticks)
    elif zlim is not None:
        zticks = np.logspace(np.log10(zlim[0]), np.log10(zlim[1]),
                         int(np.round(np.log10(zlim[1]/zlim[0]) + 1)))
        axPow.set_xticks(zticks)
    zticklabels = ['']
    for k in np.arange(1, zticks.shape[0]):
        zticklabels.append(r'$10^{%d}$' % int(np.round(np.log10(zticks[k]))))
    axPow.set_xticklabels(zticklabels)
    plt.setp(axPow.get_xticklabels(), fontsize='large')
    plt.minorticks_off()
    axPow.grid()
# Import necessary modules
import matplotlib.pyplot as plt
import numpy as np

# Name output file
psname = 'python_plot.ps'

# Create data and labels for the bar plot.
data1 = [1, 0.6, 0.8]
data2 = [0.85, 0.4, 0.95]
labels = ['0.4 Z$_\odot$', '1 Z$_\odot$', '2.5 Z$_\odot$']   

# Set up plot
fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim(-0.1, 2.7, plt.minorticks_off())
ax.set_ylim(0., 1.2, plt.minorticks_on())

ind = np.arange(len(data1))
width = .3

# Plot bars
ax.bar(ind, data1, width, color='darkslateblue', ec='white')
ax.bar(ind+width, data2, width, color='royalblue', ec='white')

# Add axes labels and titles (x), and annotations
ax.set_xlabel('Metallicity', size=18)
ax.set_ylabel('Normalized Frequency', size=18)


ax.set_xticks(ind+width)
def main():

    if len(sys.argv) != 2:
        print "Usage: ", sys.argv[0], "<simout directory>"
        exit(-1)

    try:
        stats = open(sys.argv[1] + "/stats.txt", "r")
    except IOError:
        print "Failed to open ", sys.argv[1] + "/stats.txt", " for reading"
        exit(-1)

    try:
        simout = open(sys.argv[1] + "/simout", "r")
    except IOError:
        print "Failed to open ", sys.argv[1] + "/simout", " for reading"
        exit(-1)

    # Get the address ranges
    got_ranges = False
    ranges = []

    iterations = 1

    for line in simout:
        if got_ranges:
            ranges.append(int(line) / 1024)

        match = re.match("lat_mem_rd with (\d+) iterations, ranges:.*", line)
        if match:
            got_ranges = True
            iterations = int(match.groups(0)[0])

    simout.close()

    if not got_ranges:
        print "Failed to get address ranges, ensure simout is up-to-date"
        exit(-1)

    # Now parse the stats
    raw_rd_lat = []

    for line in stats:
        match = re.match(".*readLatencyHist::mean\s+(.+)\s+#.*", line)
        if match:
            raw_rd_lat.append(float(match.groups(0)[0]) / 1000)
    stats.close()

    # The stats also contain the warming, so filter the latency stats
    i = 0
    filtered_rd_lat = []
    for l in raw_rd_lat:
        if i % (iterations + 1) == 0:
            pass
        else:
            filtered_rd_lat.append(l)
        i = i + 1

    # Next we need to take care of the iterations
    rd_lat = []
    for i in range(iterations):
        rd_lat.append(filtered_rd_lat[i::iterations])

    final_rd_lat = map(lambda p: min(p), zip(*rd_lat))

    # Sanity check
    if not (len(ranges) == len(final_rd_lat)):
        print "Address ranges (%d) and read latency (%d) do not match" % (len(ranges), len(final_rd_lat))
        exit(-1)

    for (r, l) in zip(ranges, final_rd_lat):
        print r, round(l, 2)

    # lazy version to check if an integer is a power of two
    def is_pow2(num):
        return num != 0 and ((num & (num - 1)) == 0)

    plt.semilogx(ranges, final_rd_lat)

    # create human readable labels
    xticks_locations = [r for r in ranges if is_pow2(r)]
    xticks_labels = []
    for x in xticks_locations:
        if x < 1024:
            xticks_labels.append("%d kB" % x)
        else:
            xticks_labels.append("%d MB" % (x / 1024))
    plt.xticks(xticks_locations, xticks_labels, rotation=-45)

    plt.minorticks_off()
    plt.xlim((xticks_locations[0], xticks_locations[-1]))
    plt.ylabel("Latency (ns)")
    plt.grid(True)
    plt.show()
rects = plt.bar(index, values_lme, bar_width, alpha=0.3, color='r', label='LME', linewidth=0)
for i, rect in enumerate(rects):
    height = rect.get_height()
    plt.text(rect.get_x() + rect.get_width() / 2., -1 * height, 'LME', ha='center', va='bottom', fontsize=4, rotation=90)

rects = plt.bar(index + bar_width, values_iflux, bar_width, alpha=0.3, color='b', label='CF', linewidth=0)
for i, rect in enumerate(rects):
    height = rect.get_height()
    plt.text(rect.get_x() + rect.get_width() / 2., -1 * height, 'CF', ha='center', va='bottom', fontsize=4, rotation=90)

rects = plt.bar(index + bar_width * 2, values_mem, bar_width, alpha=0.3, color='k', label='CF', linewidth=0)
for i, rect in enumerate(rects):
    height = rect.get_height()
    plt.text(rect.get_x() + rect.get_width() / 2., -1 * height, 'CF-Mem', ha='center', va='bottom', fontsize=4, rotation=90)

plt.xticks(index + bar_width, (r'Yes 50', r'Yes 100', r'F.Sq 10'))

ax = plt.gca()
ax.tick_params(direction='out', pad=0.3)
ax.set_ylim((-5, -8))
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')

plt.minorticks_off()
plt.ylabel('Avg. LL (Test Set)', labelpad=0)
#plt.legend(frameon=False, loc='upper left')
plt.tight_layout(pad=0.2)
plt.savefig('ll_lme.pdf')
def base_fraction_plot(
    base_count_position_list_dict,
    flank_size=10,
    normalize_to_GC_contents=1,
    overall_GC_content=0.5,
    genome_info="",
    add_markers=True,
    ytick_scale=1,
    bases_plotstyles={"A": "g^-", "T": "rv-", "C": "bs-", "G": "yo-"},
):
    """ Plot the base fractions at each position, with given flanksize, normalized to GC content or not.

    Base_count_position_list_dict should be the output of base_count_dict.
    Normalize_to_GC_contents can be: 
     - 0 - no normalization (show raw base fractions)
     - 1 - difference between real and expected base contents 
            (so the difference between 0.1 and 0.3, and between 0.3 and 0.5, will be the same 0.2), 
     - 2 - ratio between real and expected base contents (the 0.1 to 0.3 ratio is same as 0.3 to 0.9, bigger than 0.3 to 0.5)
     - 3 - ratio on a log-scale (so that ratios of 1/4, 1/2, 1, 2, 4 are all equidistant, which makes sense,
            instead of 1, 2, 3 being equidistant and 1/2, 1/3, ..., 1/10 being all squished between 0 and 1 like on the linear scale)

    Ytick_scale is only applicable when normalize_to_GC_contents is 3:  
     - if it's 1, the ticks will be ..., 2, 1, 1/2, ...
     - if it's 2, the ticks will be ..., 2, 3/2, 1, 3/2, 1/2, ...
     - if it's 3, the ticks will be ..., 2, 5/3, 4/3, 1, 3/4, 3/5, 1/2, ...
    """
    if not 0 <= normalize_to_GC_contents <= 3:
        raise Exception("normalize_to_GC_contents must be 0/1/2/3, not %s!" % normalize_to_GC_contents)
    real_base_fraction_list_dict = base_fraction_dict_from_count_dict(base_count_position_list_dict)
    pos_after_insertion = int(len(real_base_fraction_list_dict["A"]) / 2)
    expected_base_fractions = base_fractions_from_GC_content(overall_GC_content)
    all_plot_data = []
    for base in NORMAL_DNA_BASES:
        raw_plot_data = real_base_fraction_list_dict[base][
            pos_after_insertion - flank_size : pos_after_insertion + flank_size
        ]
        assert len(raw_plot_data) == flank_size * 2
        if normalize_to_GC_contents == 0:
            plot_data = raw_plot_data
        elif normalize_to_GC_contents == 1:
            plot_data = [x - expected_base_fractions[base] for x in raw_plot_data]
        else:
            plot_data = [x / expected_base_fractions[base] for x in raw_plot_data]
        all_plot_data.extend(plot_data)
        if add_markers:
            mplt.plot(plot_data, bases_plotstyles[base], label=base, markeredgecolor="none")
        else:
            mplt.plot(plot_data, bases_plotstyles[base][0], label=base)
    mplt.legend(loc=2, prop=FontProperties(size="smaller"))
    ylabel = "fraction of bases in given position"
    if normalize_to_GC_contents == 0:
        ylabel = "raw " + ylabel
    elif normalize_to_GC_contents == 1:
        ylabel += ",\nas a difference from %s GC content" % genome_info
    else:
        ylabel += ",\nas a ratio to %s GC content" % genome_info
    if normalize_to_GC_contents == 3:
        ylabel += " (log scale)"
    # make y logscale if desired; in that case I have to do the min/max/ticks sort of by hand...
    if normalize_to_GC_contents == 3:
        if min(all_plot_data) <= 0:
            raise ValueError("some bases have 0 fraction - can't plot log-scale!")
            # MAYBE-TODO plot it symlog if needed? But then all my work with limits/ticks needs to be redone...
        mplt.yscale("log")
        y_max = int(max(scipy.ceil(max(all_plot_data)), scipy.ceil(1 / min(all_plot_data))))
        mplt.ylim(1 / y_max, y_max)
        half_yticks_x = [x for x in range(ytick_scale + 1, ytick_scale * y_max + 1)]
        yticks = [ytick_scale / x for x in half_yticks_x] + [1] + [x / ytick_scale for x in half_yticks_x]
        yticklabels = (
            [Fraction(ytick_scale, x) for x in half_yticks_x] + [1] + [Fraction(x, ytick_scale) for x in half_yticks_x]
        )
        mplt.yticks(yticks, yticklabels)
        mplt.minorticks_off()

    # change the xticks to use -1 before the insertion position and 1 after, no 0
    xticks = range(flank_size * 2)
    mplt.xlim(0, flank_size * 2 - 1)
    mplt.xticks(xticks, [_relative_position_vs_cut(x, flank_size) for x in xticks])
    mplt.xlabel("relative genome position (dotted line is the insertion position)")
    mplt.ylabel(ylabel, ha="right")
    # put a dashed line at the insertion position
    ylim = mplt.ylim()
    mplt.vlines(flank_size - 0.5, *ylim, linestyles="dashed")
    mplt.ylim(*ylim)
def plot(df0a, df1a, df2a, dotmode, colorA, colorB):
    df0 = df0a[df0a['dotmode'] == dotmode]
    df1 = df1a[df1a['dotmode'] == dotmode]
    df2 = df2a[df2a['dotmode'] == dotmode]

    df = df0.groupby('dur', as_index=False)['sens'].agg([np.mean, np.std])['sens'].reset_index()
    if dotmode == '3d':
        df = df[df['dur'] > df['dur'].min()]
        df = df[df['dur'] > df['dur'].min()]

    ptA = df1[['x0','x1','b0','b1','m0','m1']].median()
    df = df[df['dur'] <= np.exp(ptA['x1'])] # ignore higher durs since line there is flat
    df['y1'] = df['dur']**ptA['m0']*np.exp(ptA['b0'])
    x1 = df['dur'] > np.exp(ptA['x0'])
    df['y1'][x1] = df['dur'][x1]**ptA['m1']*np.exp(ptA['b1'])

    ptB = df2[['b0','m0']].median()
    df['y2'] = df['dur']**ptB['m0']*np.exp(ptB['b0'])

    sz = 80
    lw1 = 1
    lw2 = 2
    df['y1e'] = (df['mean'] - df['y1'])/df['std']
    df['y2e'] = (df['mean'] - df['y2'])/df['std']
    # plt.plot(df['dur'], df['y2e'], lw=lw1, c='k', zorder=4)
    # plt.plot(df['dur'], df['y1e'], lw=lw1, c='k', zorder=4)
    plt.gca().fill_between(df['dur'], 0.0, df['y2e'], lw=0, color=colorB, facecolor=colorB, alpha=0.6, zorder=3)
    plt.gca().fill_between(df['dur'], 0.0, df['y1e'], lw=0, color=colorA, facecolor=colorA, alpha=1.0, zorder=3)
    plt.scatter(df['dur'], df['y2e'], sz, c=colorB, lw=1.5, label='bi-limb fit', zorder=5)
    plt.scatter(df['dur'], df['y1e'], sz, c=colorA, lw=1.5, label='tri-limb fit', zorder=5)

    plt.plot([np.exp(ptA['x0']), np.exp(ptA['x0'])], [-29.5, 8.5], '--', lw=lw2, c=colorA, zorder=1)
    # plt.plot([0.01, df['dur'].max() + 50], [0, 0], '-', lw=lw2, c='k', zorder=1)

    # plt.plot(df['dur'], df['mean'])
    # plt.scatter(df['dur'], df['y1'], c='g')
    # plt.scatter(df['dur'], df['y2'], c='r')
    # plt.yscale('log')
    ys = np.hstack([df['y1e'].values, df['y2e'].values])
    plt.xscale('log')
    # plt.xlim(df0a['dur'].min()-2, df['dur'].max()+30)
    # plt.ylim(ys.min()-1, ys.max()+1)
    plt.xlabel('Duration (msec)')
    plt.ylabel('Motion sensitivity residual')
    leg = plt.legend(loc='upper left', prop={'size': LegendFontSize})
    leg.get_frame().set_linewidth(1.5)
    xtcks = np.array([33, 200, 1000])
    # xtcks = xtcks[xtcks >= df['dur'].min()]
    plt.xticks(xtcks, xtcks)

    # formatting
    plt.minorticks_off()
    plt.gca().tick_params(top='off')
    plt.gca().tick_params(right='off')
    plt.gca().tick_params(axis='x', direction='out', width=1.5, length=5)
    plt.gca().tick_params(axis='y', direction='out', width=1.5, length=5)
    plt.gcf().patch.set_facecolor('white')
    for axis in ['bottom', 'left']:
        plt.gca().spines[axis].set_linewidth(lw2)
    for axis in ['top', 'right']:
        plt.gca().spines[axis].set_linewidth(0)
Exemple #49
0
    def fillActivityTab(self):
        """
        Fills and displays the bar graph in the activity tab.
        """
        taskID = self.activityTaskID

        # First get the absolute value of today.
        today = datetime.date.today()
        delta = datetime.timedelta(days=1)

        # Now construct shiftable intervals.
        beginInt = datetime.datetime
        endInt = datetime.datetime

        # Default scale (days): Begin interval at midnight of today.
        beginInt = datetime.datetime(today.year, today.month, today.day, 0, 0, 0)
        shiftDelta = delta

        if self.intervalScale == 2:  # Scale: Weeks
            # Begin interval at midnight of this weeks monday.
            weekDayNum = calendar.weekday(today.year, today.month, today.day)
            beginInt = beginInt - delta * weekDayNum
            shiftDelta = 7 * delta
        elif self.intervalScale == 1:  # Scale: Months
            # Begin interval at midnight of the first day of the month.
            beginInt = datetime.datetime(today.year, today.month, 1, 0, 0, 0)
            shiftDelta = 30 * delta
        self.shiftDelta = shiftDelta

        # Get the data of the last units since today.
        units = list()
        values = list()
        size = 6 + self.intervalScale

        for i in range(size):
            # Shift
            offset = size - i - 1 - self.intervalShift
            shiftedBegin = beginInt - offset * shiftDelta
            # When scaled to months, an arithmetical shift is not practical.
            if self.intervalScale == 1:
                yearDiff, monDiff = divmod(offset, 12)
                newMon = beginInt.month - monDiff
                if newMon < 0:
                    newMon = 12 + newMon
                    yearDiff += 1

                if newMon == 0:
                    newMon = 12
                    yearDiff += 1

                shiftedBegin = datetime.datetime(beginInt.year - yearDiff, newMon, 1, 0, 0, 0)
            shiftedEnd = datetime.datetime

            if self.intervalScale == 3:
                units.append(str(shiftedBegin.month) + "/" + str(shiftedBegin.day))
                shiftedEnd = datetime.datetime(shiftedBegin.year, shiftedBegin.month, shiftedBegin.day, 23, 59, 59)
            elif self.intervalScale == 2:
                units.append(shiftedBegin.strftime("CW %W"))
                shiftedEnd = datetime.datetime(shiftedBegin.year, shiftedBegin.month, shiftedBegin.day, 23, 59, 59)
                shiftedEnd = shiftedEnd + delta * 6
            else:
                units.append(shiftedBegin.strftime("%b %y"))
                lastDay = calendar.monthrange(shiftedBegin.year, shiftedBegin.month)[1]
                shiftedEnd = datetime.datetime(shiftedBegin.year, shiftedBegin.month, lastDay, 23, 59, 59)
            timeInt = [int(shiftedBegin.timestamp()), int(shiftedEnd.timestamp())]
            values.append(self.pomo.pomoData.getPomoCount(timeInt, taskID))

        # Disable left buttons once we scrolled far enough
        if self.pomo.pomoData.firstPomo != 0:
            shiftedBegin = beginInt - (size - 1 - self.intervalShift) * shiftDelta
            self.shiftedBegin = shiftedBegin
            if shiftedBegin.timestamp() <= self.pomo.pomoData.firstPomo:
                self.leftButtonHandle.setDisabled(True)
                self.farLeftButtonHandle.setDisabled(True)
            else:
                self.leftButtonHandle.setDisabled(False)
                self.farLeftButtonHandle.setDisabled(False)

        # Create a new subplot.
        ax = self.figure.add_subplot(111)
        ax.hold(False)

        # Create the bar graphs
        bars = ax.bar(list(range(1, size + 1)), values, width=0.4, align="center", color="#E04B3F")
        for bar in bars:
            height = bar.get_height()
            plt.text(
                bar.get_x() + bar.get_width() / 2.0,
                height + 0.08,
                "%d" % int(height),
                ha="center",
                va="bottom",
                weight="medium",
            )
        plt.xticks(list(range(1, size + 1)), units)

        # y-Limit of the graph depends on the maximum bar height.
        yLim = self.highestPomoCount[self.intervalScale - 1] * 1.24

        # To avoid rescaling the graph when changing the task, we lock the
        # y-Limit to the first one generated after startup.
        if self.lockYLim is False:
            if yLim == 0:
                # When no pomodoros have been done, use a constant y-Limit.
                yLim = 15
            else:
                self.lockYLim = True
            self.yLim = yLim
        else:
            # Update the y-Limit when it exceeds the saved one.
            if yLim > self.yLim:
                self.yLim = yLim

        # Set the graph limits.
        ax.set_ylim([0, self.yLim])
        ax.set_xlim([0.5, size + 0.5])

        # Additional plot and graph settings.
        plt.subplots_adjust(left=0, right=0.99, top=1, bottom=0.087)
        ax.get_yaxis().set_visible(False)
        plt.minorticks_off()
        for tick in ax.get_xticklines():
            tick.set_visible(False)

        # Write currently viewed month and year in the upper right corner,
        # when zoomed out, only display the year.
        if self.intervalScale != 1:
            tempDate = beginInt - (size - 1 - self.intervalShift) * shiftDelta
            dateString = tempDate.strftime("%b %Y")
            if self.intervalScale != 3:
                dateString = tempDate.strftime("%Y")

            plt.text(
                0.99,
                0.937,
                dateString,
                horizontalalignment="right",
                verticalalignment="center",
                transform=ax.transAxes,
                weight="bold",
            )

        # Show.
        self.canvas.draw()
Exemple #50
0
def main(trace_fpath, lat_long_fpath, leaveout=0.3):
    initialize_matplotlib()
    leaveout = float(leaveout)
    
    lat_long_dict = {}
    with open(lat_long_fpath) as lat_long_file:
        for line in lat_long_file:
            loc, lat, long_ = line.split('\t')
            lat_long_dict[loc] = (float(lat), float(long_))

    df = pd.read_csv(trace_fpath, sep='\t', names=['dt', 'u', 's', 'd'])
    
    num_lines = len(df)
    to = int(num_lines - num_lines * leaveout)
    
    df_train = df[:to]
    df_test = df[to:]
    
    pop_df = df_train.groupby(['d']).count()['u']
    pop_dict = dict(zip(pop_df.index, pop_df.values))
    answer_df = df_train.groupby(['s', 'd']).count()['u']
    answer_dict = dict(zip(answer_df.index, answer_df.values))
    
    X = []
    y = []
    for row in df_train[['s', 'd']].values:
        s, d = row
        if s in pop_dict and d in pop_dict and \
                str(s) in lat_long_dict and str(d) in lat_long_dict:
            dist = distance(str(s), str(d), lat_long_dict)
            if dist == 0: #different ids, same loc, ignore
                continue

            X.append([1.0, np.log(pop_dict[s]), np.log(pop_dict[d]), -np.log(dist)])
            y.append(answer_dict[s, d])
    
    answer_df_test = df_test.groupby(['s', 'd']).count()['u']
    answer_dict_test = dict(zip(answer_df_test.index, answer_df_test.values))
    
    #This is future information, should not be exploited for likelihood
    pop_df_test = df_test.groupby(['d']).count()['u']
    pop_dict_test = dict(zip(pop_df_test.index, pop_df_test.values))

    X_test_ll = []
    X_test_pred = []

    y_test = []
    for row in df_test[['s', 'd']].values:
        s, d = row
        if s in pop_dict and d in pop_dict and \
                str(s) in lat_long_dict and str(d) in lat_long_dict:

            dist = distance(str(s), str(d), lat_long_dict)
            if dist == 0: #different ids, same loc, ignore
                continue
            
            X_test_ll.append([1.0, np.log(pop_dict[s]), np.log(pop_dict[d]), \
                    -np.log(dist)])
            X_test_pred.append([1.0, np.log(pop_dict_test[s] if s in pop_dict_test else 0), \
                    np.log(pop_dict_test[d]), -np.log(dist)])
            y_test.append(answer_dict_test[s, d])

    X_train = np.asarray(X)
    y_train = np.asarray(y)

    X_test_ll = np.asarray(X_test_ll)
    X_test_pred = np.asarray(X_test_pred)

    y_test = np.asarray(y_test)
    
    import time
    print('training', time.localtime())
    model = sm.GLM(y_train, X_train, family=sm.families.Poisson())
    results = model.fit()
    print('done', time.localtime())
    print(results.summary()) 
    
    y_pred = np.array(results.predict(X_test_pred))
    print(np.abs(y_test - y_pred).mean())
    
    plt.plot(y_pred, y_test, 'wo', rasterized=True, markersize=2)
    plt.plot(y_pred, y_pred, 'r-', rasterized=True)
    plt.minorticks_off()

    ax = plt.gca()
    ax.tick_params(direction='out', pad=0.3)
    ax.spines['right'].set_visible(False)
    ax.spines['top'].set_visible(False)
    ax.xaxis.set_ticks_position('bottom')
    ax.yaxis.set_ticks_position('left')

    plt.ylabel(r'True value ($n_{ds}$)', labelpad=0.2)
    plt.xlabel(r'Predicted value ($\tilde{n_{ds}}$)', labelpad=0.3)
    plt.tight_layout(pad=0.1)
    _, _, r, _, _ = linregress(y_pred, y_test)
    plt.title('MAE = %.3f ; R2 = %.3f ' %(np.abs(y_test - y_pred).mean(), r**2), y=0.8)
    plt.savefig('pred.pdf')

    #Likelihood on test set (adapted from glm code on train set,
    #no method for test set exists)
    lin_pred = np.dot(X_test_ll, results.params) + model._offset_exposure
    expval = model.family.link.inverse(lin_pred)
    llr = model.family.loglike(expval, y_test, results.scale)
    llr = llr
    print(llr, llr / X_test_ll.shape[0]) 
Exemple #51
0
def plot_t_wf_a(wf, save="", range_x=None, range_y=None):
    """
    Plot wavefront in Q-space.

    :params: wf: wavefront structure

    :params: save: Whether to save the figure on disk
    :type:  string for filename. Empty string '' means don't save.
    :default: '', do not save the figure.

    :params: range_x: x-axis range.
    :type: float
    :default: None, take entire x range.

    :params: range_y: y-ayis range.
    :type: float
    :default: None, take entire y range.

    """
    import matplotlib.pyplot as plt

    wf_intensity = wf.get_intensity().sum(axis=-1)
    plt.figure(figsize=(10, 10), dpi=100)
    plt.axis("tight")
    try:
        plt.set_cmap("viridis")
    except:
        plt.set_cmap("YlGnBu_r")

    profile = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=2)
    xmin, xmax, ymax, ymin = wf.get_limits()

    profile.imshow(wf_intensity, extent=[xmin * 1.0e6, xmax * 1.0e6, ymax * 1.0e6, ymin * 1.0e6])
    profile.set_aspect("equal", "datalim")

    # [LS:2016-03-17]
    # change shape dimension, otherwise, in case nx!=ny ,
    # 'x, y should have the same dimension' error from py plot
    # x = numpy.linspace(xmin*1.e6,xmax*1.e6,wf_intensity.shape[0])
    # y = numpy.linspace(ymin*1.e6,ymax*1.e6,wf_intensity.shape[1])
    x = numpy.linspace(xmin * 1.0e6, xmax * 1.0e6, wf_intensity.shape[1])
    y = numpy.linspace(ymin * 1.0e6, ymax * 1.0e6, wf_intensity.shape[0])
    profile.set_xlabel(r"$\mu$rad", fontsize=12)
    profile.set_ylabel(r"$\mu$rad", fontsize=12)

    x_projection = plt.subplot2grid((3, 3), (0, 0), sharex=profile, colspan=2)
    print(x.shape, wf_intensity.sum(axis=0).shape)
    x_projection.plot(x, wf_intensity.sum(axis=0), label="x projection")
    if range_x is None:
        profile.set_xlim([xmin * 1.0e6, xmax * 1.0e6])
    else:
        profile.set_xlim([-range_x / 2.0, range_x / 2.0])

    y_projection = plt.subplot2grid((3, 3), (1, 2), rowspan=2, sharey=profile)
    y_projection.plot(wf_intensity.sum(axis=1), y, label="y projection")

    # Hide minor tick labels.
    plt.minorticks_off()

    if range_y is None:
        profile.set_ylim([ymin * 1.0e6, ymax * 1.0e6])
    else:
        profile.set_ylim([-range_y / 2.0, range_y / 2.0])

    if save != "":
        plt.savefig(save)
    else:
        plt.show()
Exemple #52
0
def plot_t_wf(wf, save="", range_x=None, range_y=None):
    """
    Plot wavefront in  R-space.

    :params: wf: wavefront structure

    :params: save: Whether to save the figure on disk
    :type:  string for filename. Empty string '' means don't save.
    :default: '', do not save the figure.

    :params: range_x: x-axis range.
    :type: float
    :default: None, take entire x range.

    :params: range_y: y-ayis range.
    :type: float
    :default: None, take entire y range.
    """
    import matplotlib.pyplot as plt

    # Get the wavefront and integrate over time.
    wf_intensity = wf.get_intensity().sum(axis=-1)

    # Get average and time slicing.
    average = averaged_intensity(wf, bPlot=True)
    nslices = wf.params.Mesh.nSlices
    dt = (wf.params.Mesh.sliceMax - wf.params.Mesh.sliceMin) / (nslices - 1)
    t0 = dt * nslices / 2 + wf.params.Mesh.sliceMin

    # Setup a figure.
    figure = plt.figure(figsize=(10, 10), dpi=100)
    plt.axis("tight")
    # Set colormap. Inferno is not available in all matplotlib versions, fall
    # back to gnuplot.
    try:
        plt.set_cmap("viridis")
    except:
        plt.set_cmap("YlGnBu_r")

    # Profile plot.
    profile = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=2)

    # Get limits.
    xmin, xmax, ymax, ymin = wf.get_limits()

    # Plot profile as 2D colorcoded map.
    profile.imshow(wf_intensity, extent=[xmin * 1.0e3, xmax * 1.0e3, ymax * 1.0e3, ymin * 1.0e3])
    profile.set_aspect("equal", "datalim")

    # Get x and y ranges.
    # [LS:2016-03-17]
    # change shape dimension, otherwise, in case nx!=ny ,
    # 'x, y should have the same dimension' error from py plot
    # x = numpy.linspace(xmin*1.e3,xmax*1.e3,wf_intensity.shape[0])
    # y = numpy.linspace(ymin*1.e3,ymax*1.e3,wf_intensity.shape[1])
    x = numpy.linspace(xmin * 1.0e3, xmax * 1.0e3, wf_intensity.shape[1])
    y = numpy.linspace(ymin * 1.0e3, ymax * 1.0e3, wf_intensity.shape[0])

    # Labels.
    profile.set_xlabel("$mm$", fontsize=12)
    profile.set_ylabel("$mm$", fontsize=12)

    # x-projection plots above main plot.
    x_projection = plt.subplot2grid((3, 3), (0, 0), sharex=profile, colspan=2)
    print(x.shape, wf_intensity.sum(axis=0).shape)

    x_projection.plot(x, wf_intensity.sum(axis=0), label="x projection")

    # Set range according to input.
    if range_x is None:
        profile.set_xlim([xmin * 1.0e3, xmax * 1.0e3])
    else:
        profile.set_xlim([-range_x / 2.0, range_x / 2.0])

    # Set title.
    x_projection.set_title(
        "relative intensity={:03.3g}, t0={:03.2f} fs".format(wf_intensity.sum() / average, t0 * 1.0e15)
    )

    # y-projection plot right of main plot.
    y_projection = plt.subplot2grid((3, 3), (1, 2), rowspan=2, sharey=profile)
    y_projection.plot(wf_intensity.sum(axis=1), y, label="y projection")

    # Hide minor tick labels, they disturb here.
    plt.minorticks_off()

    # Set range according to input.
    if range_y is None:
        profile.set_ylim([ymin * 1.0e3, ymax * 1.0e3])
    else:
        profile.set_ylim([-range_y / 2.0, range_y / 2.0])

    # If requested, save to disk, otherwise show in interactive window.
    if save != "":
        # Add parameters.
        plt.savefig(save)
    else:
        plt.show()
def despine():
    ax = py.gca()
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    py.tick_params(axis='both', bottom='on', top='off', left='on', right='off')
    py.minorticks_off()
Exemple #54
0
def MultiDimNewtRaph(f,x0,dx=1e-6,args=(),ytol=1e-4,w=1.0,JustOneStep=False):
    """
    A Newton-Raphson solver where the Jacobian is always re-evaluated rather than
    re-using the information as in the fsolve method of scipy.optimize
    """
    x=np.array(x0)
    error=999
    J=np.zeros((len(x),len(x)))
    
    error_list=[]
    iteration_list = []
    
    #If a float is passed in for dx, convert to a numpy-like list the same shape
    #as x
    if isinstance(dx,float):
        dx=dx*np.ones_like(x)
        
    r0=array(f(x,*args))
    while abs(error)>ytol:
        #Build the Jacobian matrix by columns
        for i in range(len(x)):
            epsilon=np.zeros_like(x)
            epsilon[i]=dx[i]
            J[:,i]=(array(f(x+epsilon,*args))-r0)/epsilon[i]
        v=np.dot(-inv(J),r0)
        x=x+w*v
        #Calculate the residual vector at the new step
        r0=f(x,*args)
        error = np.max(np.abs(r0))
        iteration=my_counter_2.next()
        
        error_list.append(error)
        iteration_list.append(iteration)
        #print error
        #Just do one step and stop
        if JustOneStep==True:
            return x
    
    error_convergence = np.array(error_list)
    iteration_convergence = np.array(iteration_list)
    print '---MultiDimNewtRaph---'
    print iteration_convergence
    print error_convergence
    matplotlib.rc('text', usetex=True)
    plt.rc('font', family='serif')
    fig=figure(figsize=(8,6))
    ax=fig.add_subplot(1,1,1)

    plot(iteration_convergence, error_convergence,'bs-',linewidth=2.0,markersize = 10,markerfacecolor="blue", markeredgewidth=2, markeredgecolor="black")
    plt.axhline(y=1e-5,color='r',ls='dashed', linewidth=2.5)
    xlabel('Iteration [-] ',fontsize=18)
    ylabel(r'$|Resid|$',fontsize=18)
    title('Overall Cycle Convergence',fontsize=18)
    
    plt.yscale('log')
    plt.minorticks_off() 
    for tickx in ax.xaxis.get_major_ticks():
        tickx.label.set_fontsize(20)
    for ticky in ax.yaxis.get_major_ticks():
        ticky.label.set_fontsize(20)
    
    show()
    fig.savefig('MultiDimNewtRaph.png',dpi=300)
    return x
        
    
Exemple #55
0
def setupPlot(minZ, zMed, maxZ, imSize, imSizePlot, minR, maxR, minSM, maxSM, morph, thisPanel, nPanels, legendFlag):
    # setup plot of SM vs R with colorbar

    if(nPanels==1):
       lmarg=0.03
       rmarg=0.08
       bmarg=0.1
       tmarg=0.02
       nCols=1
       nRows=1
       rect=np.array([lmarg,bmarg,(1.-rmarg-lmarg),(1.-tmarg-bmarg)])

       tickLabelSize=14
       figSize=(8,6)
       zFontSize='medium'
       barFontSize='x-small'
       morphFontSize='medium'
    else:
       lmarg=0.1
       rmarg=0.01
       bmarg=0.2
       tmarg=0.01
       nCols=np.min([3,nPanels])
       nRows=int(np.ceil(float(nPanels)/nCols))
       thisCol=int(np.remainder(thisPanel,nCols))
       thisRow=int(np.floor(float(thisPanel)/nCols))
       panelWidth=(1.-rmarg-lmarg)/nCols
       panelHeight=(1.-tmarg-bmarg)/nRows
       rect=np.array([lmarg+thisCol*panelWidth,bmarg+(nRows-thisRow-1)*panelHeight,panelWidth,panelHeight])

       tickLabelSize=14
       figSize=(8,9)
       zFontSize=10
       barFontSize=7
       morphFontSize=9

    if(thisPanel==0):
           # use helvetica and latex
           plt.rc('font',**{'family':'sans-serif','sans-serif':['Helvetica'],'size':20})
           plt.rc('text', usetex=True)
           plt.rc('axes',linewidth=1.5)
           plt.rc('xtick',labelsize=tickLabelSize)
           plt.rc('ytick',labelsize=tickLabelSize)
           xStr=r'Distance from Group Center [R/R$_{200{\rm c}}$]'
           yStr=r'Stellar Mass [log(M$_{\star}/$M$_{\odot}$)]'
                  
           # start the plot with axes
           fig=plt.figure(1,figsize=figSize)

    # there will be a main figure with the galaxies and a second for the colorbar
    # a set of axes will be created for each panel and for the colorbar
    if(nPanels==1): 
           ax1=plt.axes(rect)

           plt.xlabel(xStr,fontsize='medium')
           plt.ylabel(yStr,fontsize='medium')

    else:
           ax1=plt.axes(rect)

           if(thisPanel==0):
              fig.text(lmarg+0.5*(1.-lmarg-rmarg),0.75*bmarg,xStr,fontsize='medium',horizontalalignment='center',verticalalignment='center',rotation='horizontal')
              fig.text(0.22*lmarg,bmarg+0.5*(1.-bmarg-tmarg),yStr,fontsize='medium',horizontalalignment='center',verticalalignment='center',rotation='vertical')
           
           if(thisCol != 0):
                  plt.setp(ax1.get_yticklabels(),visible=False)
           if((thisRow != nRows) & (thisPanel+nCols < nPanels)):
                  plt.setp(ax1.get_xticklabels(),visible=False)

    if(legendFlag):
       # overlay morph category text
       yMorph=0.97
       oplotMorphText(plt,yMorph,morphFontSize)
       plt.setp(ax1.get_xticklines(),visible=False)
       plt.setp(ax1.get_yticklines(),visible=False)
       plt.minorticks_off()
       axThick=5
       axColor='black'
       ax1.axhline(linewidth=axThick,color=axColor)
       ax1.axvline(linewidth=axThick,color=axColor)
       ax1.axhline(y=1,linewidth=axThick,color=axColor)
       ax1.axvline(x=1,linewidth=axThick,color=axColor)
    else:
       # z range text (upper right)
       xText=0.95
       yText=0.95
       oplotZRange(plt, xText, yText, minZ, maxZ, zFontSize)

       # scale bar (below z range)
       xBar=xText
       yBar=0.82
       oplotScaleBar(plt, xBar, yBar, zMed, imSize, imSizePlot, barFontSize)
    
    # print morph type (title)
#    setMorphTitle(plt, morph)

       # bottom shaded region for SM limit
       smLimit=getSMLimit(maxZ)
       oplotSMLimit(plt, smLimit, minSM, maxSM)

       # left shaded region for centrals
       oplotCentralRegion(plt, minR, maxR, minSM, maxSM, smLimit)

       plt.minorticks_on()

    # axes
    plt.xlim((0,1))
    plt.ylim((0,1))

    xticks=np.linspace(0,1,num=6)
    plt.xticks((xticks-minR)/(maxR-minR),xticks)

    yticks=np.linspace(10,12,num=3)
    plt.yticks((yticks-minSM)/(maxSM-minSM),yticks)

    marg=np.array([lmarg,rmarg,bmarg,tmarg])
    return (plt,ax1,marg)