Example #1
0
def pr_plot(y, preds, fname=None, figsize=(8, 6), verbose=True):
    """
    Plot a precision-recall curve and compute the AUC.

    :param y: numpy 1-d array of true target data
    :param preds: numpy 1-d array of target predictions
    :param fname: filename of saved plot, default is None (do not save)
    :param figsize: (width in, height in) tuple
    :param verbose: boolean, if True write precision-recall plot AUC to logger
    :return: None
    """
    precision, recall, thresh = precision_recall_curve(y, probas_pred=preds)
    pr_auc = auc(recall, precision)

    fig = plt.figure(figsize=figsize)
    plt.step(recall, precision, color='b', alpha=0.2, where='post')
    plt.fill_between(recall, precision, step='post', alpha=0.2, color='b')
    plt.xlabel('Recall')
    plt.ylabel('Precision')
    plt.ylim([0.0, 1.05])
    plt.xlim([0.0, 1.0])
    plt.title('Precision-recall curve ---- AUC = {:6.4f}'.format(pr_auc))

    if fname:
        plt.savefig(fname)

    if verbose:
        logging.info('Precision-recall AUC = {:6.4f}'.format(pr_auc))
Example #2
0
def test_sparse_fused_lasso(n=500,l1=2.,ratio=1.,control=control):

    D = (np.identity(n) - np.diag(np.ones(n-1),-1))[1:]
    D = np.vstack([D, ratio*np.identity(n)])
    M = np.linalg.eigvalsh(np.dot(D.T, D)).max() 

    Y = np.random.standard_normal(n)
    Y[int(0.1*n):int(0.3*n)] += 3.
    p1 = sapprox.signal_approximator((D, Y),L=M)
    p1.assign_penalty(l1=l1)
    
    t1 = time.time()
    opt1 = regreg.FISTA(p1)
    opt1.fit(tol=control['tol'], max_its=control['max_its'])
    beta1 = opt1.problem.coefs
    t2 = time.time()
    ts1 = t2-t1

    beta, _ = opt1.output
    X = np.arange(n)
    if control['plot']:
        pylab.clf()
        pylab.step(X, beta, linewidth=3, c='red')
        pylab.scatter(X, Y)
        pylab.show()
Example #3
0
    def plot(self, ylog10scale = False, timescale = "years", year = 25):
        """
        Generate figure and axis for the population structure
        timescale choose from "2N0", "4N0", "generation" or "years"
        """
        time = self.Time
        pop  = self.pop
        for i in range(1,len(self.pop)):
            if type(pop[i]) == type(""):
                # ignore migration commands, and replace by (unchanged) pop size
                pop[i] = pop[i-1]
        
        if time[0] != 0 :
            time.insert(0, float(0))
            pop.insert(0, float(1))
        
        if timescale == "years":
            time = [ti * 4 * self.scaling_N0 * year for ti in time ]
            pl.xlabel("Time (years, "+`year`+" years per generation)",  fontsize=20)    
            #pl.xlabel("Years")    
        elif timescale == "generation":
            time = [ti * 4 * self.scaling_N0 for ti in time ]
            pl.xlabel("Generations)")    
        elif timescale == "4N0":
            time = [ti*1 for ti in time ]
            pl.xlabel("Time (4N generations)")    
        elif timescale == "2N0":
            time = [ti*2 for ti in time ]
            pl.xlabel("Time (2N generations)")       
        else:
            print "timescale must be one of \"4N0\", \"generation\", or \"years\""
            return
        
        time[0] = time[1] / float(20)
        
        time.append(time[-1] * 2)
        yaxis_scaler = 10000
        
        pop = [popi * self.scaling_N0 / float(yaxis_scaler) for popi in pop ]
        pop.insert(0, pop[0])               
        pl.xscale ('log', basex = 10)        
        #pl.xlim(min(time), max(time))
        pl.xlim(1e3, 1e7)
        
        if ylog10scale:
            pl.ylim(0.06, 10000)
            pl.yscale ('log', basey = 10)            
        else:
            pl.ylim(0, max(pop)+2)
        
        pl.ylim(0,5)            
        pl.tick_params(labelsize=20)

        #pl.step(time, pop , color = "blue", linewidth=5.0)
        pl.step(time, pop , color = "red", linewidth=5.0)
        pl.grid()
        #pl.step(time, pop , color = "black", linewidth=5.0)
        #pl.title ( self.case + " population structure" )
        #pl.ylabel("Pop size ($*$ "+`yaxis_scaler` +")")
        pl.ylabel("Effective population size",fontsize=20 )
Example #4
0
def observe_maihara_region_custom(combos=[(3200, .3, "k")], labels=[""]):

    pl.figure(1)

    for combo in combos:
        R, frac, fmt = combo
        lp, sp, spl, prof_l, prof = to_observed(ll,
                                                ss,
                                                16000 / R * AA,
                                                N=125 * 512 * frac * 3,
                                                nsamp=2.8)
        pl.step(lp, -2.5 * np.log10(np.abs(spl)), fmt)
        #pl.step(lp, spl)

    pl.ylim(5, -2)
    #pl.ylim(-0.1, 0.5)
    pl.legend(labels)
    pl.xlim(16400, 16900)
    pl.axvline(16600, color='red')
    pl.axvline(16700, color='red')
    pl.axhline(3 + .75, color='black')
    pl.grid(True)

    pl.xlabel(r"Wavelength [$\rm \AA$]")
    pl.ylabel(r"$F_\lambda$ [magnitude]")
Example #5
0
def plot_attenuation_sim(rmArray, f, days_in_season=82, n_iter=1000, label=''):
	N = days_in_season
	l2 = (0.3 / f) ** 2
	hist, bins = np.histogram(rm, bins=np.arange(min(rmArray), max(rmArray) + bin_width, bin_width))
	bin_midpoints = bins[:-1] + np.diff(bins) / 2
	cdf = np.cumsum(hist)
	cdf = cdf / cdf[-1]
	values = np.random.rand(n_iter)
	value_bins = np.searchsorted(cdf, values)
	random_from_cdf = bin_midpoints[value_bins]

	factors = []

	for i, RM in enumerate(random_from_cdf):
		atten = 0
		for j in range(i + 1, N, 1):
			atten += np.cos(2 * (random_from_cdf[j] - RM) * l2)
		factor = (float(N) + (2. * atten)) / pow(float(N), 2.)
		factors.append(factor)

	Pv, v = np.histogram(factors, bins=10, density=True)
	print('Epsilon (sim) =', np.mean(factors), '+/-', np.std(factors))
	v = 0.5 * (v[1:] + v[:-1])
	pylab.step(v, Pv, label=label)

	return [np.mean(factors), np.std(factors)]
Example #6
0
def measure_flexure_y(fine, HDUlist, profwidth=5, plot=False, outname=None):

    dat = HDUlist[0].data
    exptime = HDUlist[0].header["EXPTIME"]

    profs = []
    xx = np.arange(profwidth * 2)

    for ix in np.arange(500, 1200, 10):
        f = fine[ix]
        profile = np.zeros(profwidth * 2)

        # bad fit
        if not f.ok:
            continue
        # noisy fit
        if f.lamnrms > 1:
            continue
        # short spectrum
        if f.xrange[1] - f.xrange[0] < 200:
            continue

        yfun = np.poly1d(f.poly)
        for xpos in np.arange(f.xrange[0], f.xrange[1]):
            try:
                ypos = int(np.round(yfun(xpos)))
            except:
                continue
            try:
                profile += dat[ypos - profwidth : ypos + profwidth, xpos]
            except:
                continue

        profs.append(profile - np.min(profile))

    if plot:
        pl.figure(1)
    ffun = FF.mpfit_residuals(FF.gaussian4)
    parinfo = [{"value": 1}, {"value": profwidth}, {"value": 2}, {"value": 0}, {"value": 0}]

    profposys = []
    for prof in profs:
        if plot:
            pl.step(xx, prof)
        parinfo[0]["value"] = np.max(prof)
        fit = FF.mpfit_do(ffun, xx, prof, parinfo)
        if plot:
            pl.plot(xx, FF.gaussian4(fit.params, xx))
        profposys.append(fit.params[1] - profwidth - 1)
    if plot:
        pl.show()
    profposys = np.array(profposys)

    mn = np.mean(profposys)
    sd = np.std(profposys)
    ok = np.abs(profposys - mn) / sd < 3
    required_shift = np.mean(profposys[ok])
    print "dY = %3.2f pixel shift" % required_shift

    return required_shift
Example #7
0
    def _cumdist(sample, annotation='', color='k'):
        order = np.argsort(sample['giso_insol'].values)[::-1]
        w = np.cumsum(sample['weight'].values[order]) / num_stars
        n = np.array(range(len(sample['weight'].values))) / float(len(sample))
        f = sample['giso_insol'].values[order]

        pl.step(f,
                n,
                'k-',
                lw=2,
                linestyle='dashed',
                alpha=0.25,
                color=color,
                label=None)
        pl.step(f, w / np.max(w), 'k-', lw=2, color=color)

        aloc = (0.1, 0.85)
        #pl.annotate(annotation, xy=aloc, xycoords='axes fraction', fontsize=20,
        #            horizontalalignment='left')

        pl.semilogx()

        pl.xlim(2000, 30)
        pl.ylim(0, 1)

        ax = pl.gca()
        ax.xaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())
        ax.xaxis.set_major_formatter(
            matplotlib.ticker.FormatStrFormatter('%0.0f'))
        ax.xaxis.set_ticks([30, 100, 300, 1000, 3000])

        pl.xlabel('Stellar light intensity relative to Earth (S)')
        # pl.ylabel('cumulative fraction of planet detections')
        pl.ylabel(r'Fraction of planets with S$_{\rm inc} < S$')
Example #8
0
def test_sparse_fused_lasso(n=500, l1=2., ratio=1., control=control):

    D = (np.identity(n) - np.diag(np.ones(n - 1), -1))[1:]
    D = np.vstack([D, ratio * np.identity(n)])
    M = np.linalg.eigvalsh(np.dot(D.T, D)).max()

    Y = np.random.standard_normal(n)
    Y[int(0.1 * n):int(0.3 * n)] += 3.
    p1 = sapprox.signal_approximator((D, Y), L=M)
    p1.assign_penalty(l1=l1)

    t1 = time.time()
    opt1 = regreg.FISTA(p1)
    opt1.fit(tol=control['tol'], max_its=control['max_its'])
    beta1 = opt1.problem.coefs
    t2 = time.time()
    ts1 = t2 - t1

    beta, _ = opt1.output
    X = np.arange(n)
    if control['plot']:
        pylab.clf()
        pylab.step(X, beta, linewidth=3, c='red')
        pylab.scatter(X, Y)
        pylab.show()
Example #9
0
def test_metropolis(Nsamp=int(1e4), Nburnin=0, sampleSig=5, thetaInit=-5):
    from scipy import stats
    import pylab as plt

    def testfunc(theta):
        return (stats.cauchy(-10, 2).pdf(theta)
                + 4 * stats.cauchy(10, 4).pdf(theta))

    def lnp(theta):
        """ interface to metrop """
        return (0, np.log10(testfunc(theta)))

    x = np.linspace(-50, 50, 1e4)
    y = testfunc(x)

    # compute normalization function: used later to put on same as histogram
    Zfunc = np.sum(y * x.ptp() / len(x))

    plt.plot(x, y / Zfunc, 'k-', lw=2)
    plt.xlabel('theta')
    plt.ylabel('f')

    lnps, samples = metropolis(lnp, [thetaInit], Nburnin=Nburnin, Nsamp=Nsamp,
                               sampleCov=sampleSig ** 2)

    n, b = np.histogram(samples.ravel(), bins=np.arange(-50, 50, 1),
                        normed=False)
    Zhist = (n * np.diff(b)).sum()
    plt.step(b[1:], n.astype(float) / Zhist, color='r')
    plt.title('test metropolis')
Example #10
0
def test_metropolis(Nsamp=int(1e4), Nburnin=0, sampleSig=5, thetaInit=-5):
    from scipy import stats
    import pylab as plt

    def testfunc(theta):
        return (stats.cauchy(-10, 2).pdf(theta) +
                4 * stats.cauchy(10, 4).pdf(theta))

    def lnp(theta):
        """ interface to metrop """
        return (0, np.log10(testfunc(theta)))

    x = np.linspace(-50, 50, 1e4)
    y = testfunc(x)

    # compute normalization function: used later to put on same as histogram
    Zfunc = np.sum(y * x.ptp() / len(x))

    plt.plot(x, y / Zfunc, 'k-', lw=2)
    plt.xlabel('theta')
    plt.ylabel('f')

    lnps, samples = metropolis(lnp, [thetaInit],
                               Nburnin=Nburnin,
                               Nsamp=Nsamp,
                               sampleCov=sampleSig**2)

    n, b = np.histogram(samples.ravel(),
                        bins=np.arange(-50, 50, 1),
                        normed=False)
    Zhist = (n * np.diff(b)).sum()
    plt.step(b[1:], n.astype(float) / Zhist, color='r')
    plt.title('test metropolis')
Example #11
0
def psmc_figure(cum_change, tmrca, position, prefix):
    X, Y, Z, site, time = psmc_XYZ(prefix)
    fig = pl.figure(figsize=(24, 7))
    pl.pcolor(X, Y, Z, vmin=0, vmax=0.15)
    my_axes = fig.gca()
    #ylabels = ["%.4g" % (float(y)*2 * default_pop_size) for y in my_axes.get_yticks()]
    ylabels = ["%.4g" % (float(y)) for y in my_axes.get_yticks()]
    my_axes.set_yticklabels(ylabels)

    #pl.colorbar()
    pl.step(
        cum_change, [x * 2 for x in tmrca], color="red", linewidth=15.0
    )  # becasue x is generated by ms, which is scaled to 4N0, psmc scale to 2N0. Thereofore, needs to multiply by 2
    #pl.step(cum_change, [x for x in tmrca] , color = "red", linewidth=5.0)
    pl.plot(position, [0.9 * max(time)] * len(position), "wo", markersize=15)
    pl.axis([0, max(site), 0, max(time)])
    pl.title("PSMC heat map", fontsize=25)
    pl.xlabel("Sequence base", fontsize=20)
    #pl.ylabel("TMRCA (generation)")
    pl.ylabel("TMRCA (2N0)", fontsize=20)
    #my_axes.set_yticklabels([])
    #my_axes.set_xticklabels([])
    pl.savefig(prefix + "psmc_heat" + ".png", transparent=True)
    print "done"
    pl.close()
Example #12
0
def createPlot(dataY, dataX, ticksX, annotations, axisY, axisX, dostep, doannotate):
    if not ticksX:
        ticksX = dataX
    
    if dostep:
        py.step(dataX, dataY, where='post', linestyle='-', label=axisY) # where=post steps after point
    else:
        py.plot(dataX, dataY, marker='o', ms=5.0, linestyle='-', label=axisY)
    
    if annotations and doannotate:
        for note, x, y in zip(annotations, dataX, dataY):
            py.annotate(note, (x, y), xytext=(2,2), xycoords='data', textcoords='offset points')

    py.xticks(np.arange(1, len(dataX)+1), ticksX, horizontalalignment='left', rotation=30)
    leg = py.legend()
    leg.draggable()
    py.xlabel(axisX)
    py.ylabel('time (s)')

    # Set X axis tick labels as rungs
    #print zip(dataX, dataY)
  
    py.draw()
    py.show()
    
    return
Example #13
0
    def OnZPlotProfile(self, event):
        x, p, d, pi = self.vp.GetProfile(50, background=[7, 7])

        pylab.figure(1)
        pylab.clf()
        pylab.step(x, p)
        pylab.step(x, 10 * d - 30)
        pylab.ylim(-35, pylab.ylim()[1])

        pylab.xlim(x.min(), x.max())

        pylab.xlabel('Time [%3.2f ms frames]' %
                     (1e3 * self.mdh.getEntry('Camera.CycleTime')))
        pylab.ylabel('Intensity [counts]')

        fr = self.fitResults[pi]

        if not len(fr) == 0:
            pylab.figure(2)
            pylab.clf()

            pylab.subplot(211)
            pylab.errorbar(
                fr['tIndex'],
                fr['fitResults']['x0'] -
                self.vp.do.xp * 1e3 * self.mdh.getEntry('voxelsize.x'),
                fr['fitError']['x0'],
                fmt='xb')
            pylab.xlim(x.min(), x.max())
            pylab.xlabel('Time [%3.2f ms frames]' %
                         (1e3 * self.mdh.getEntry('Camera.CycleTime')))
            pylab.ylabel('x offset [nm]')

            pylab.subplot(212)
            pylab.errorbar(
                fr['tIndex'],
                fr['fitResults']['y0'] -
                self.vp.do.yp * 1e3 * self.mdh.getEntry('voxelsize.y'),
                fr['fitError']['y0'],
                fmt='xg')
            pylab.xlim(x.min(), x.max())
            pylab.xlabel('Time [%3.2f ms frames]' %
                         (1e3 * self.mdh.getEntry('Camera.CycleTime')))
            pylab.ylabel('y offset [nm]')

            pylab.figure(3)
            pylab.clf()

            pylab.errorbar(
                fr['fitResults']['x0'] -
                self.vp.do.xp * 1e3 * self.mdh.getEntry('voxelsize.x'),
                fr['fitResults']['y0'] -
                self.vp.do.yp * 1e3 * self.mdh.getEntry('voxelsize.y'),
                fr['fitError']['x0'],
                fr['fitError']['y0'],
                fmt='xb')
            #pylab.xlim(x.min(), x.max())
            pylab.xlabel('x offset [nm]')
            pylab.ylabel('y offset [nm]')
 def plot_t(self):
     import pylab
     super(ConvexProblem2D, self).plot_t()
     pylab.step(
         [0., 2. * self.switch_times[-1]], [self.omega_i ** 2] * 2, 'g',
         linestyle='--', where='post')
     pylab.step(
         [0., 2. * self.switch_times[-1]], [self.omega_f ** 2] * 2, 'k',
         linestyle='--', where='post')
 def plot_s(self):
     import pylab
     super(ConvexProblem2D, self).plot_s()
     pylab.step(
         [0., 1.], [self.omega_i ** 2] * 2, 'g', linestyle='--',
         where='post')
     pylab.step(
         [0., 1.], [self.omega_f ** 2] * 2, 'k', linestyle='--',
         where='post')
def graphical_output(account_balance_giro, account_balance_extra, depot_balance_extra, giro_data,
                     daily_account_balance):
    years = mdates.YearLocator()  # every year
    months = mdates.MonthLocator()
    weeks = mdates.WeekdayLocator()
    days = mdates.DayLocator()

    dateFormat = mdates.DateFormatter('%Y-%m-%d')
    yearFormat = mdates.DateFormatter('%Y-%m')

    fig = pl.figure()

    pl.xlabel("date")
    pl.ylabel("balance")
    ax1 = pl.subplot(121)
    pl.xlabel("date")
    pl.ylabel("account balance")
    pl.title("account balances")

    ax1.step(daily_account_balance[:, 0], daily_account_balance[:, 1])
    ax1.step(daily_account_balance[:, 0], daily_account_balance[:, 2])
    ax1.step(daily_account_balance[:, 0], daily_account_balance[:, 3])
    ax1.step(daily_account_balance[:, 0], daily_account_balance[:, 4])
    ax1.xaxis.set_major_locator(months)
    ax1.xaxis.set_major_formatter(yearFormat)
    # ax1.xaxis.set_minor_locator(weeks)
    ax1.format_xdata = mdates.DateFormatter('%Y-%m-%d')
    ax1.xaxis_date()
    pl.legend(["Giro Account", "Extra Account", "Depot", "Total"], loc="best")

    ax2 = pl.subplot(122)
    pl.xlabel("date")
    pl.ylabel("bookings")
    pl.title("giro account bookings")
    ax2.bar(giro_data[:, 0], giro_data[:, 4])
    # ax2.bar(extra_data[:,0], extra_data[:,4]) too much stuff going on
    ax2.xaxis.set_major_locator(months)
    ax2.xaxis.set_major_formatter(yearFormat)
    ax2.xaxis.set_minor_locator(weeks)
    ax2.format_xdata = mdates.DateFormatter('%Y-%m-%d')
    ax2.xaxis_date()
    fig.autofmt_xdate()

    fig = pl.figure()

    daily_account_balance_diff = daily_account_balance[30:, :] - daily_account_balance[:-30, :]
    daily_account_balance_diff[:, 0] = daily_account_balance[30:, 0]
    # print daily_account_balance_diff
    pl.xlabel("date")
    pl.ylabel("balance")
    pl.step(daily_account_balance_diff[:, 0], daily_account_balance_diff[:, -1])
    pl.axhline(y=0, xmin=0, xmax=1)
    pl.legend(["Total 30 day difference"], loc="best")

    pl.show()
Example #17
0
def interpret_msmc(top_param = program_parameters(), scaling_method = "2N0", year = 1, ylog10scale = False ):
    if scaling_method == "generation":
        scaling_method = "years"
        year = 1

    #msmc_para = program_parameters()
    #top_param  = msmc_para
    ####### This two lines should be outside, after called
    
    replicates = top_param.replicates
    nsample    = top_param.nsample
    case       = top_param.case
      
    dir_name = "msmc-experiment/" + case + "Samples" +`nsample`
    ms_param = param.ms_param_of_case(case)
    
    ms_param.plot(ylog10scale = ylog10scale, timescale = scaling_method, year = year)
    
    mu = ms_param.t / ms_param.seqlen / float(4) / ms_param.scaling_N0 

    for ith_run in range(replicates):
        ms_out_file_prefix = ms_param.case + \
                             "Samples" +`nsample` + \
                             "msdata"

        outputFile_name = dir_name + "/" + ms_out_file_prefix + ".final.txt"
        if os.path.isfile( outputFile_name ):
            #print outputFile_name
            outputFile = open ( outputFile_name, "r")
            tmp_time , tmp_lambda = [] , []        
            skipline = outputFile.readline()
           
            for line in outputFile:
                tmp_time.append( float(line.split()[1]) )
                tmp_lambda.append( float(line.split()[3]) )
            
            #print tmp_time, tmp_lambda
            if scaling_method == "years":
                time = [ ti / mu * year for ti in tmp_time]
            elif scaling_method == "2N0":
                time = [ ti / mu / ( 2* float(ms_param.scaling_N0) ) for ti in tmp_time]
            elif scaling_method == "4N0":
                time = [ ti / mu / ( 4* float(ms_param.scaling_N0)) for ti in tmp_time]
                
            time[0] = time[1]/float(100)
            time.append(time[-1]*float(100))
            yaxis_scaler = float(10000)
            pop = [ 1 / lambda_i / (2*mu) / yaxis_scaler for lambda_i in tmp_lambda]
            pop.insert(0, pop[0])              
            pylab.step(time, pop, color = "purple", linewidth=2.0)
            #print pop

            outputFile.close()
    pylab.savefig( dir_name + ".pdf" )            
    pylab.close()            
Example #18
0
def my_cdf(data):
    data.sort()
    n = len(data)
    y = []
    for i in range(n):
	y.append((float(i)+1)/n)

    p.step(data, y)
    p.title('CDF')
    p.show()        
    pass
Example #19
0
def plot_data(xs, data, tellurics=False, telluric_xs=[0.0], plotname="data.png"):
    # plot the data    
    plt.clf()
    for n in range(8):
        plt.step(xs, data[n, :] + 0.25 * n, color="k")
        if tellurics:
            assert telluric_xs.all() > 0.0
            for t in telluric_xs:
                plt.axvline(t, color='b', alpha=0.25, lw=1)
    plt.title("examples of data")
    plt.savefig(plotname)
Example #20
0
def plot_beam_events(events,
                     side=None,
                     timerange=None,
                     height=1.0,
                     offset=0.0,
                     color='b'):
    b = db.sel(events, event='beam', data0=side, timerange=timerange)
    if len(b) == 0:
        return
    pylab.step(b[:, consts.TIME_COLUMN],
               b[:, consts.BEAM_STATE_COLUMN] * height + offset,
               where='post',
               color=color)
Example #21
0
def plot_touch_binary_events(events,
                             side=None,
                             timerange=None,
                             height=1.0,
                             offset=0.0,
                             color='g'):
    b = db.sel(events, event='touch_binary', data0=side, timerange=timerange)
    if len(b) == 0:
        return
    pylab.step(b[:, consts.TIME_COLUMN],
               b[:, consts.TOUCH_STATE_COLUMN] * height + offset,
               where='post',
               color=color)
Example #22
0
def my_ccdf(data):
    # in-place sort
    data.sort()
    n = len(data)
    y = []
    for i in range(n):
	y.append(1-(float(i)+1)/n)
    p.step(data, y)
    p.ylabel('ccdf(x)')
    p.xlabel('x')
    p.title('CCDF')
    p.show()        
    pass
Example #23
0
def plotFluxE(fluxVec, energyVec=None, fnameOut='fluxE', figNum=0, label='fluxE'):
    if not energyVec:
        # assume 10 energy grp structure by default
        energyVec = np.array([1e-3, 1e-2, 1e-1, 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7])
    fluxVec = np.append(np.array([0]), fluxVec)
    plt.figure(figNum)
    plt.step(energyVec, fluxVec / np.sum(fluxVec), linewidth='4', label=label)
    plt.ylim([5e-3, 1])
    plt.xscale('log')
    plt.yscale('log')
    plt.xlabel("Energy (eV)")
    plt.ylabel("Log Flux (Arbitrary Scaling)")
    plt.legend()
    plt.savefig(fnameOut)
Example #24
0
def measure_flexure(sky):
    ''' Measure expected (589.3 nm) - measured emission line in nm'''
    ll, ss = sky['nm'], sky['ph_10m_nm']

    pl.figure()
    pl.step(ll, ss)

    pix = SG.argrelmax(ss, order=20)[0]
    skynms = chebval(pix, sky['coefficients'])
    for s in skynms: pl.axvline(s)

    ixmin = np.argmin(np.abs(skynms - 589.3))
    dnm = 589.3 - skynms[ixmin]

    return dnm
Example #25
0
def diCal_figure (cum_change, tmrca, position, prefix):
    tmrca = [x*2 for x in tmrca] # convert tmrca from unit of 4Ne to 2Ne
    site, absorptionTime = extract_diCal_time ( prefix )
    maxtime = max( max(absorptionTime), max(tmrca) )
    
    fig = pl.figure(figsize=(24,7)) 
    pl.plot(site, absorptionTime, color = "green", linewidth=3.0)
    pl.step(cum_change, tmrca, color = "red", linewidth=5.0)
    pl.plot(position, [maxtime*1.05]*len(position), "bo")    
    pl.axis([min(site), max(site) , 0, maxtime*1.1])
    pl.title("Dical Absorption time (Green)")
    pl.xlabel("Sequence base")
    pl.ylabel("TMRCA (2N0)")
    pl.savefig( prefix + "diCal_absorption_time" + ".png")
    pl.close()
Example #26
0
def diCal_figure(cum_change, tmrca, position, prefix):
    tmrca = [x * 2 for x in tmrca]  # convert tmrca from unit of 4Ne to 2Ne
    site, absorptionTime = extract_diCal_time(prefix)
    maxtime = max(max(absorptionTime), max(tmrca))

    fig = pl.figure(figsize=(24, 7))
    pl.plot(site, absorptionTime, color="green", linewidth=3.0)
    pl.step(cum_change, tmrca, color="red", linewidth=5.0)
    pl.plot(position, [maxtime * 1.05] * len(position), "bo")
    pl.axis([min(site), max(site), 0, maxtime * 1.1])
    pl.title("Dical Absorption time (Green)")
    pl.xlabel("Sequence base")
    pl.ylabel("TMRCA (2N0)")
    pl.savefig(prefix + "diCal_absorption_time" + ".png")
    pl.close()
Example #27
0
def measure_flexure(sky):
    ''' Measure expected (589.3 nm) - measured emission line in nm'''
    ll, ss = sky['nm'], sky['ph_10m_nm']

    pl.figure()
    pl.step(ll, ss)

    pix = SG.argrelmax(ss, order=20)[0]
    skynms = chebval(pix, sky['coefficients'])
    for s in skynms:
        pl.axvline(s)

    ixmin = np.argmin(np.abs(skynms - 589.3))
    dnm = 589.3 - skynms[ixmin]

    return dnm
Example #28
0
def xsPlot(xs, energyVec=None, micro=True, label='xs1', style='-', fnameOut='xsPlt', figNum=4):
    if not energyVec:
        # assume 10 energy grp structure by default
        energyVec = np.array([1e-3, 1e-2, 1e-1, 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7])
    xsVec = np.append(np.array([0]), xs)
    plt.figure(figNum)
    plt.step(energyVec, xsVec, linewidth='4', label=label, linestyle=style)
    plt.yscale('log')
    plt.xscale('log')
    plt.xlabel("Energy (eV)")
    if micro:
        plt.ylabel("Micro Xsection [barns]")
    else:
        plt.ylabel("Macro Xsection [1/cm]")
    plt.legend()
    plt.savefig(fnameOut)
Example #29
0
def measure_flexure_y(fine, HDUlist, profwidth=5, plot=False, outname=None):
    
    dat = HDUlist[0].data
    exptime = HDUlist[0].header['EXPTIME']

    profs = []
    xx = np.arange(profwidth*2)

    for ix in np.arange(500, 1200, 10):
        f = fine[ix]
        profile = np.zeros(profwidth*2)

        if not f.ok: continue
        if f.lamrms > 1: continue
        if f.xrange[1] - f.xrange[0] < 200: continue

        yfun = np.poly1d(f.poly)
        for xpos in np.arange(f.xrange[0], f.xrange[1]):
            try:    ypos = int(np.round(yfun(xpos)))
            except: continue
            try: profile += dat[ypos-profwidth:ypos+profwidth, xpos]
            except: continue
            
        profs.append(profile - np.min(profile))

    if plot: pl.figure(1)
    ffun = FF.mpfit_residuals(FF.gaussian4)
    parinfo= [{'value': 1}, {'value': profwidth}, {'value': 2}, 
        {'value': 0}, {'value': 0}]

    profposys = []
    for prof in profs:
        if plot: pl.step(xx, prof)
        parinfo[0]['value'] = np.max(prof)
        fit = FF.mpfit_do(ffun, xx, prof, parinfo)
        if plot: pl.plot(xx, FF.gaussian4(fit.params, xx))
        profposys.append(fit.params[1] - profwidth-1)
    if plot: pl.show()
    profposys = np.array(profposys)

    mn = np.mean(profposys)
    sd = np.std(profposys)
    ok = np.abs(profposys - mn)/sd < 3
    required_shift = np.mean(profposys[ok])
    print "dY = %3.2f pixel shift" % required_shift
        
    return required_shift
Example #30
0
 def plot_t(self):
     """
     Plot :math:`\\lambda(t)` and :math:`\\omega(t)^2` curves.
     """
     from pylab import grid, legend, plot, step, xlabel, ylim
     times = list(self.switch_times) + [2 * self.switch_times[-1]]
     lambda_ = list(self.lambda_[-1::-1])
     trange = linspace(0, max(times), 20)
     omega_ = [self.omega_from_t(t)**2 for t in trange]
     step(times, lambda_, marker='o', where='pre')
     plot(trange, omega_, 'r-', marker='o')
     legend(('$\\lambda(t)$', '$\\omega(t)^2$'))
     xlabel('$t$', fontsize=18)
     ymin = 0.9 * min(min(self.lambda_), min(omega_))
     ymax = 1.1 * max(max(self.lambda_), max(omega_))
     ylim((ymin, ymax))
     grid()
Example #31
0
File: pana.py Project: sverres/pana
def makePlot(XS, YS, XP, YP, XG, YG, XF, YF):
    pylab.figure(figsize=(20, 8))

    pylab.subplot(1, 2, 1)
    pylab.plot(XS, YS, 'o', XP, YP, '+')
    pylab.axis([0, 100, 0, 100])
    pylab.grid(True)
    pylab.xlabel("x-coordinate")
    pylab.ylabel("y-coordinate")

    pylab.subplot(1, 2, 2)
    pylab.step(XG, YG, XF, YF, where='post', linewidth=1)
    pylab.axis([0, 100, -0.1, 1.1])
    pylab.grid(True)
    pylab.xlabel("Distance (d)")
    pylab.ylabel("G(d), F(d)")

    pylab.show()
Example #32
0
 def PrintHistogram(self, spec):
     """
     print histogramm
     """
     nbins = spec.hist.hist.GetNbinsX()
     # create values for x axis
     en = numpy.arange(nbins)
     # shift in order to get values at bin center
     en = en - 0.5
     # calibrate
     en = self.ApplyCalibration(en, spec.cal)
     # extract bin contents to numpy array
     data = numpy.zeros(nbins)
     for i in range(nbins):
         data[i] = spec.hist.hist.GetBinContent(i)
     # create spectrum plot
     (r, g, b) = hdtv.color.GetRGB(spec.color)
     pylab.step(en, data, color=(r, g, b), label=spec.name)
Example #33
0
def plot_precision_recall(precision, recall, f1_score, plotting_string):
    pylab.figure()

    pylab.step(recall, precision, color='b', alpha=0.2, where='post')
    pylab.fill_between(recall, precision, step='post', alpha=0.2, color='b')

    pylab.xlabel('Recall')
    pylab.ylabel('Precision')
    pylab.ylim([0.0, 1.05])

    pylab.xlim([0.0, 1.0])

    print('Saving figure %sprecision_recall_%s.pdf' %
          (analysis_directory, plotting_string))

    pylab.savefig(os.path.expanduser('%sprecision_recall_%s.pdf' %
                                     (analysis_directory, plotting_string)),
                  bbox_inches='tight')
Example #34
0
def plot_attenuation(rmArray, f, label):
	N = rmArray.shape[0]
	l2 = (0.3 / f) ** 2
	factors = []
	for i, RM in enumerate(rmArray):
		atten = 0
		for j in range(i + 1, N, 1):
			atten += np.cos(2 * (rmArray[j] - RM) * l2)

		factor = (float(N) + (2. * atten)) / pow(float(N), 2.)
		factors.append(factor)

	Pv, v = np.histogram(factors, bins=10, density=True)
	print('Epsilon=', np.mean(factors), '+/-', np.std(factors))
	v = 0.5 * (v[1:] + v[:-1])
	pylab.step(v, Pv, label=label)

	return [np.mean(factors), np.std(factors)]
Example #35
0
def plot_1d_pdfs(cldata):
    grid = cldata['match']['grid']
    logpr = grid['fit']
    pr = np.exp(-0.5 * logpr)
    pr /= pr.sum()

    plt.figure(figsize=(15, 4))

    plt.subplot(141)
    y = np.unique(grid['age'])
    dy = get_bins_from_center(y)
    n, b = plt.histogram(cldata['match']['grid']['age'], bins=dy, weights=pr)
    c = figrc.get_centers_from_bins(b)
    p = n * np.diff(b) * c
    plt.step(10**c, p / p.sum(), where='mid', color='k', lw=2)
    plt.xscale('log')
    figrc.hide_axis('top right'.split())
    plt.xlabel('age [yr]')

    plt.subplot(142)
    Y = grid['av']
    y = np.unique(Y)
    dy = get_bins_from_center(y)
    n, b = plt.histogram(Y, bins=dy, weights=pr)
    c = figrc.get_centers_from_bins(b)
    plt.step(c, n / n.sum(), where='mid', color='k', lw=2)
    figrc.hide_axis('top right'.split())
    plt.xlabel('Av [mag]')

    plt.subplot(143)
    Y = grid['z']
    y = np.unique(Y)
    dy = get_bins_from_center(y)
    n, b = plt.histogram(Y, bins=dy, weights=pr)
    c = figrc.get_centers_from_bins(b)
    plt.step(c, n / n.sum(), where='mid', color='k', lw=2)
    figrc.hide_axis('top right'.split())
    plt.xlabel(r'Log(Z/Z$_\odot$)')

    plt.subplot(144)
    Y = grid['mass']
    dlogm = 0.1
    y = np.unique(Y)
    dy = np.arange(dlogm, 6, dlogm)
    n, b = plt.histogram(Y, bins=dy, weights=pr)
    c = figrc.get_centers_from_bins(b)
    p = n * np.diff(b) * c
    # plt.step(c, n / n.sum(), where='mid')
    plt.step(10**c, p / p.sum(), where='mid', color='k', lw=2)
    plt.xscale('log')
    figrc.hide_axis('top right'.split())
    plt.xlabel(r'Mass [M$_\odot$]')

    plt.tight_layout()
Example #36
0
def radius_dist_old():
    physmerge = io.load_table('cks3').dropna(subset=['gdir_prad'])
    weights = pd.read_csv

    print(len(physmerge),
          (physmerge.gdir_srad_err1 / physmerge.gdir_srad).median())

    rmask, rbin_centers, rN, re, result1, result2 = fitting.histfit(
        physmerge, completeness=False, verbose=False)

    mask, bin_centers, N, e, result1, result2 = fitting.histfit(
        physmerge, completeness=True, boot_errors=False)

    histfitplot(physmerge,
                bin_centers,
                N,
                e,
                mask,
                result1,
                result2,
                completeness=True,
                plotmod=False)
    pl.grid(False)

    rN = rN / (float(num_stars) * np.mean(physmerge['tr_prob']))
    pl.step(rbin_centers,
            rN,
            color='0.5',
            where='mid',
            lw=3,
            linestyle='dotted')

    c2 = (0, 146 / 255., 146 / 255.)
    c1 = (146 / 255., 0, 0)

    # pl.axvline(1.0, color=c1, linestyle='dashed', lw=2)
    # pl.axvline(1.745, color=c1, linestyle='dashed', lw=2)
    # pl.axvspan(1.0, 1.75, color=c1, alpha=0.1)

    # pl.axvline(1.760, color=c2, linestyle='dashed', lw=2)
    # pl.axvline(3.5, color=c2, linestyle='dashed', lw=2)
    # pl.axvspan(1.75, 3.5, color=c2, alpha=0.1)

    pl.ylim(0, 0.16)
Example #37
0
def money_plot_plain():
    physmerge = io.load_table(config.filtered_sample)

    print(len(physmerge),
          (physmerge.gdir_srad_err1 / physmerge.gdir_srad).median())

    rmask, rbin_centers, rN, re, result1, result2 = fitting.histfit(
        physmerge, completeness=False, verbose=False)

    mask, bin_centers, N, e, result1, result2 = fitting.histfit(
        physmerge, completeness=True, boot_errors=False)

    histfitplot(physmerge,
                bin_centers,
                N,
                e,
                mask,
                result1,
                result2,
                completeness=True,
                plotmod=False)
    pl.grid(False)

    rN = rN / (float(num_stars) * np.mean(physmerge['tr_prob']))
    pl.step(rbin_centers,
            rN,
            color='0.5',
            where='mid',
            lw=3,
            linestyle='dotted')

    c2 = (0, 146 / 255., 146 / 255.)
    c1 = (146 / 255., 0, 0)

    # pl.axvline(1.0, color=c1, linestyle='dashed', lw=2)
    # pl.axvline(1.745, color=c1, linestyle='dashed', lw=2)
    # pl.axvspan(1.0, 1.75, color=c1, alpha=0.1)

    # pl.axvline(1.760, color=c2, linestyle='dashed', lw=2)
    # pl.axvline(3.5, color=c2, linestyle='dashed', lw=2)
    # pl.axvspan(1.75, 3.5, color=c2, alpha=0.1)

    pl.ylim(0, 0.125)
Example #38
0
def plotFluxE(fluxVec,
              energyVec=None,
              fnameOut='fluxE',
              figNum=0,
              label='fluxE'):
    if not energyVec:
        # assume 10 energy grp structure by default
        energyVec = np.array(
            [1e-3, 1e-2, 1e-1, 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7])
    fluxVec = np.append(np.array([0]), fluxVec)
    plt.figure(figNum)
    plt.step(energyVec, fluxVec / np.sum(fluxVec), linewidth='4', label=label)
    plt.ylim([5e-3, 1])
    plt.xscale('log')
    plt.yscale('log')
    plt.xlabel("Energy (eV)")
    plt.ylabel("Log Flux (Arbitrary Scaling)")
    plt.legend()
    plt.savefig(fnameOut)
Example #39
0
def plot_clocks(trial,speeds,probs):
    speeds = [str(i) for i in speeds]
    probs = [str(i) for i in probs]
    with open("trial%d/log_0.log"%trial) as f0, open("trial%d/log_1.log"%trial) as f1, open("trial%d/log_2.log"%trial) as f2:
        pt.figure(1, figsize=(6, 6))
        content0 = f0.readlines()
        content1 = f1.readlines()
        content2 = f2.readlines()
        contents = [content0,content1,content2]
        for i, content in enumerate(contents):
            data = [(get_time(line,"System Time","|"), int(line.split("Logical Clock")[1].strip())) for line in content]
            times = [packet[0] for packet in data]
            clocks = [packet[1] for packet in data]
            pt.step(times,clocks, label="Speed (%s)" % (speeds[i]))
        pt.grid(True)
        pt.xlabel('time (s)')
        pt.ylabel('Logical Clock Value')
        pt.title('Clock Comparison, Speeds (%s), Probabilities (%s)' % (",".join(speeds), ",".join(probs)))
        pt.legend(loc=2)
        pt.savefig('speeds%s_probs%s.png' % ("_".join(speeds), "_".join(probs)))
Example #40
0
def plotpdf(name, data, weights, label, xmin, xmax, bestfit, bdelta=0.1):
	"""  make pdf plots for age, av, and z
	inputs:  cluster name; array of parameters (age, av, or z) from matchoutput file; fit values from matchoutput file; 
        string name of parameter; minimum value of parameter to plot; maximum value of parameter to plot; best fit value of parameter; bin size
        output:  apXXX/apXXX_XXXptiles.txt"""

   	hdelta=bdelta/2.
  	nbins=np.around((data.max()-data.min())/bdelta)+1
  	xbins=np.linspace(np.around(data.min()-hdelta,3),np.around(data.max()+bdelta+hdelta,3),nbins+2)	#calculate bins
  	h = np.histogram(data, bins=xbins, weights=weights)						#create histogram of data
  	hist = h[0]/np.sum(h[0])									#normalize histogram
  	ptiles = output.weighted_percentile(data, weights, [0.16, 0.5, 0.84])				#compute percentiles
	np.savetxt(name+'/'+name+'_'+label+'ptiles.txt', ptiles)					#save these weighted percentiles
	plt.axvspan(ptiles[0], ptiles[2], color='0.8', alpha=0.5)
	plt.step(np.linspace(data.min(), data.max(), len(h[0])), hist, color='black', lw=3)
	plt.axvline(ptiles[1], color='r', lw=2)
	plt.axvline(bestfit, color='b', lw=2)
	plt.ylim(np.min(hist.min(), 0), hist.max()*1.05)
	plt.xlim(xmin, xmax)
	plt.xlabel(label)
Example #41
0
def fused_lasso(n=100, l1=2., **control):

    D = (np.identity(n) - np.diag(np.ones(n - 1), -1))[1:]
    Dsp = scipy.sparse.lil_matrix(D)
    M = np.linalg.eigvalsh(np.dot(D.T, D)).max()

    Y = np.random.standard_normal(n)
    Y[int(0.1 * n):int(0.3 * n)] += 6.

    p1 = sapprox.gengrad_sparse((Dsp, Y), L=M)
    p1.assign_penalty(l1=l1)

    p2 = sapprox.gengrad((D, Y), L=M)
    p2.assign_penalty(l1=l1)

    t1 = time.time()
    opt1 = regreg.FISTA(p1)
    opt1.debug = True
    opt1.fit(tol=control['tol'], max_its=control['max_its'])
    beta1 = opt1.problem.coefs
    t2 = time.time()
    ts1 = t2 - t1

    t1 = time.time()
    opt2 = regreg.FISTA(p2)
    opt2.fit(tol=control['tol'], max_its=control['max_its'])
    beta2 = opt2.problem.coefs
    t2 = time.time()
    ts2 = t2 - t1

    beta1, _ = opt1.output
    beta2, _ = opt2.output
    np.testing.assert_almost_equal(beta1, beta2)

    X = np.arange(n)
    if control['plot']:
        pylab.clf()
        pylab.step(X, beta1, linewidth=3, c='red')
        pylab.step(X, beta2, linewidth=3, c='green')
        pylab.scatter(X, Y)
        pylab.show()
Example #42
0
def run(trueID, predID):
    # Connect to DB
    conn = psycopg2.connect(database='taos-ii', user='******')
    cur = conn.cursor()
    cur.execute('''select id, flux_a, flux_b, flux_c, b, t, a, d from synthetic2
            where id = %s or id = %s order by id''', (trueID, predID))
    rows = cur.fetchall()

    pl.figure(figsize=(16, 6))
    gs = gridspec.GridSpec(1, 3)

    title = ''
    figure_name = ''
    for row in rows:
        figure_name += '%d_' % row[0]

        title += '[ %d: Distance = %d, Size = %.1f ] ' \
                 % (row[0], row[6], row[7])
        #title += 'b: %.2f, t: %.3f, a: %d, d:%.1f ' \
        #         % (row[4], row[5], row[6], row[7])
        for i in range(3):
            time = np.arange(len(row[i + 1])) / 20.
            time -= np.median(time)

            pl.subplot(gs[i])
            pl.step(time, row[i + 1], marker='x', label=row[0], where='mid')
            pl.legend(loc='lower right', numpoints=1)
            print len(time)
            if i % 3 == 0:
                pl.ylabel('Flux scale to one')

            #pl.subplot(gs[i + 3])
            #pl.plot(time, np.array(rows[0][i + 1]) - np.array(rows[1][i + 1]))
            pl.grid()
            if i % 3 == 0:
                pl.ylabel('Scaled flux')
            pl.xlabel('Time/sec')

    pl.suptitle(title, fontsize=15)
    #pl.savefig('%s' % figure_name[:-1])
    pl.show()
Example #43
0
def fused_lasso(n=100,l1=2.,**control):

    D = (np.identity(n) - np.diag(np.ones(n-1),-1))[1:]
    Dsp = scipy.sparse.lil_matrix(D)
    M = np.linalg.eigvalsh(np.dot(D.T, D)).max() 

    Y = np.random.standard_normal(n)
    Y[int(0.1*n):int(0.3*n)] += 6.

    p1 = sapprox.gengrad_sparse((Dsp, Y),L=M)
    p1.assign_penalty(l1=l1)

    p2 = sapprox.gengrad((D, Y),L=M)
    p2.assign_penalty(l1=l1)
    
    t1 = time.time()
    opt1 = regreg.FISTA(p1)
    opt1.debug=True
    opt1.fit(tol=control['tol'], max_its=control['max_its'])
    beta1 = opt1.problem.coefs
    t2 = time.time()
    ts1 = t2-t1

    t1 = time.time()
    opt2 = regreg.FISTA(p2)
    opt2.fit(tol=control['tol'], max_its=control['max_its'])
    beta2 = opt2.problem.coefs
    t2 = time.time()
    ts2 = t2-t1

    beta1, _ = opt1.output
    beta2, _ = opt2.output
    np.testing.assert_almost_equal(beta1, beta2)

    X = np.arange(n)
    if control['plot']:
        pylab.clf()
        pylab.step(X, beta1, linewidth=3, c='red')
        pylab.step(X, beta2, linewidth=3, c='green')
        pylab.scatter(X, Y)
        pylab.show()
Example #44
0
def plotStepChart(simulation_no, iteration_no, start_date, end_date,
                  resolution, field, country):
    """Plots step chart based on database data, recieved based on inputs
    simulation_no and iteration_no
    start_date and end_date, date resolution
    field - field which used for chart
    """

    y_all_values = db.getIterationField(
        simulation_no, iteration_no,
        field)  #get all 'field' values from database
    keys = db.getIterationField(
        simulation_no, iteration_no,
        'project_days')  #get dates for filed from database
    keys = map(lambda x: datetime.datetime.strptime(x, '%Y-%m-%d').date(),
               keys)  #converting string dates into datetime
    y_all_values = dict(
        (x, y)
        for x, y in zip(keys, y_all_values))  #getting dict [date]=field value

    x_values = []
    y_values = []
    sm = 0

    for day_from, day_to in getResolutionStartEnd(
            start_date, end_date,
            resolution):  #get dates for axis using resolution value
        delta = (day_to - day_from).days + 1  # +1 -> to include last day
        sum_period = sum([
            y_all_values[day_from + datetime.timedelta(days=days)]
            for days in range(delta)
        ])
        y_values.append(sum_period)
        x_values.append(sm + delta)
        sm += delta

    title = "{country}\n Sim. N. {simulation_no}; Iter. N. {iteration_no}. {field} {start_date}-{end_date} - res. {resolution} days".format(
        **locals())
    pylab.step(x_values, y_values)
    pylab.title(title, fontsize=12)
    pylab.show()
def plot_pixel_spectrum(i, j, data_cube, hist, params, zoom=None):
    '''
    '''
    
    if zoom == None:
        zoom = 1.0
        
    #----------------------------------
    #plotting the spectrum for a trial pixel of the map
    inds_in_pixel = hist.get_indicies([i, j])
    n = inds_in_pixel.size
    print 'number of sph particles in pixel = %d' % n  
    #ax_map.plot(x[inds_in_pixel], y[inds_in_pixel], 'y.', markersize=1, color='k')
    
    #constructing the spectrum corresponding to that pixel
    v_min, v_max = params['cube']['spec_rng']
    v_res = params['cube']['spec_res']
    
    #the velocity bins 
    v = numpy.linspace(v_min, v_max, v_res)
    
    #the spectrum of all the particles in the pixel 
    spect_pixel = data_cube[i,j,:]
    
    fig_spec = pylab.figure()
    ax_spec = fig_spec.add_axes([0.2, 0.2, 0.6, 0.6])
        
    #plotting the spectrum
    ax_spec.plot(v, spect_pixel, 'r')
    
    #rebinnign the spectrum to a lower resolution
    v_new           = scipy.ndimage.zoom(v          , zoom)
    spect_pixel_new = scipy.ndimage.zoom(spect_pixel, zoom)
    pylab.step(v_new, spect_pixel_new, 'b')
    pylab.plot(params['cube']['spec_rng'], [0.0,0.0], 'b--')
    
    pylab.xlabel(r'$v ({\rm km s}^{-1})$')
    pylab.ylabel(r'T$_{\rm antenna}$')
        
    pylab.draw()
    pylab.show()    
Example #46
0
    def plot_s(self):
        """
        Plot :math:`\\lambda(s)` and :math:`\\omega(s)^2` curves.
        """
        from pylab import grid, legend, plot, step, xlabel, ylim

        def subsample(s):
            s2 = [(s[i] + s[i + 1]) / 2. for i in xrange(len(s) - 1)]
            s2.extend(s)
            s2.sort()
            return s2

        s_more = subsample(subsample(self.s))
        omega_ = [self.omega_from_s(s)**2 for s in s_more]
        step(self.s, self.lambda_, 'b-', where='post', marker='o')
        plot(s_more, omega_, 'r-', marker='o')
        legend(('$\\lambda(s)$', '$\\omega(s)^2$'), loc='upper left')
        xlabel('$s$', fontsize=18)
        ymin = 0.9 * min(min(self.lambda_), min(omega_))
        ymax = 1.1 * max(max(self.lambda_), max(omega_))
        ylim((ymin, ymax))
        grid()
Example #47
0
def errors_advection_down(plot_results=True, T_final=1000.0, dt=100, Mz=101):
    """Test the enthalpy solver using a 'pure advection' problem with
    Neumann (in-flow) B.C. at the surface.

    We use Dirichlet B.C. at the base but they are irrelevant due
    to upwinding.
    """
    w = -1.0

    config.set_double("constants.ice.thermal_conductivity", 0.0)
    column = EnthalpyColumn(Mz, dt)
    config.set_double("constants.ice.thermal_conductivity", k)

    Lz = column.Lz
    z = np.array(column.sys.z())

    E_exact, dE_exact = exact_advection(Lz, w)

    with PISM.vec.Access(nocomm=[
            column.enthalpy, column.u, column.v, column.w,
            column.strain_heating
    ]):
        column.sys.fine_to_coarse(E_exact(z, 0), 1, 1, column.enthalpy)
        column.reset_flow()
        column.w.set(w)
        column.reset_strain_heating()

        t = 0.0
        while t < T_final:
            column.init_column()

            column.sys.set_basal_dirichlet_bc(E_exact(0, t + dt))
            column.sys.set_surface_neumann_bc(dE_exact(Lz, t + dt))

            x = column.sys.solve()

            column.sys.fine_to_coarse(x, 1, 1, column.enthalpy)

            t += dt

    if plot_results:
        plt.figure()
        plt.xlabel("z, meters")
        plt.ylabel("E, J/kg")
        plt.hold(True)
        plt.step(z, E_exact(z, 0), color="blue", label="initial condition")
        plt.step(z, E_exact(z, t), color="green", label="exact solution")
        plt.grid(True)

        plt.step(z, x, label="T={} seconds".format(t), color="red")

        plt.legend(loc="best")

    errors = E_exact(z, t) - x

    max_error = np.max(np.fabs(errors))
    avg_error = np.average(np.fabs(errors))

    return max_error, avg_error
Example #48
0
    def OnZPlotProfile(self, event):
        x,p,d, pi = self.vp.GetProfile(50, background=[7,7])

        pylab.figure(1)
        pylab.clf()
        pylab.step(x,p)
        pylab.step(x, 10*d - 30)
        pylab.ylim(-35,pylab.ylim()[1])

        pylab.xlim(x.min(), x.max())

        pylab.xlabel('Time [%3.2f ms frames]' % (1e3*self.mdh.getEntry('Camera.CycleTime')))
        pylab.ylabel('Intensity [counts]')

        fr = self.fitResults[pi]

        if not len(fr) == 0:
            pylab.figure(2)
            pylab.clf()

            pylab.subplot(211)
            pylab.errorbar(fr['tIndex'], fr['fitResults']['x0'] - self.vp.do.xp*1e3*self.mdh.getEntry('voxelsize.x'), fr['fitError']['x0'], fmt='xb')
            pylab.xlim(x.min(), x.max())
            pylab.xlabel('Time [%3.2f ms frames]' % (1e3*self.mdh.getEntry('Camera.CycleTime')))
            pylab.ylabel('x offset [nm]')

            pylab.subplot(212)
            pylab.errorbar(fr['tIndex'], fr['fitResults']['y0'] - self.vp.do.yp*1e3*self.mdh.getEntry('voxelsize.y'), fr['fitError']['y0'], fmt='xg')
            pylab.xlim(x.min(), x.max())
            pylab.xlabel('Time [%3.2f ms frames]' % (1e3*self.mdh.getEntry('Camera.CycleTime')))
            pylab.ylabel('y offset [nm]')

            pylab.figure(3)
            pylab.clf()

            pylab.errorbar(fr['fitResults']['x0'] - self.vp.do.xp*1e3*self.mdh.getEntry('voxelsize.x'),fr['fitResults']['y0'] - self.vp.do.yp*1e3*self.mdh.getEntry('voxelsize.y'), fr['fitError']['x0'], fr['fitError']['y0'], fmt='xb')
            #pylab.xlim(x.min(), x.max())
            pylab.xlabel('x offset [nm]')
            pylab.ylabel('y offset [nm]')
Example #49
0
def profile_plot(layers):
    dz, rho, rhoM, thetaM, phiM = np.asarray(layers).T
    z = np.cumsum([np.hstack((-dz[0],dz))])
    rho, rhoM, thetaM = [np.hstack((v[0],v)) for v in (rho, rhoM, thetaM)]
    pylab.step(z, rho, label='rho')
    pylab.step(z, rhoM, label='rhoM', hold=True)
    pylab.step(z, thetaM*2*np.pi/360., label='thetaM', hold=True)
    pylab.legend()
Example #50
0
def vizualizationCurves (clusters, picFormat = "png"):

    colors = ['r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w''r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b', 'g', 'c', 'k', 'm' ,'y','w', 'r', 'b']
    fig = pl.figure()
    for Ncl,cl in enumerate(clusters):
           
        for curves in cl.points:
            x, y = [], []
            sumX, sumY = 0,0
            for el in curves.elements:
                x.append(sumX + el[1])
                sumX = sumX + el[1]
                y.append(el[0])
            pl.step(x,y, color = colors[Ncl])


    # pl.xlim(50000, 130000)
    # pl.ylim(0, 5000)
    pl.xlabel("Volume, MWh")    
    pl.ylabel("Price, Rubles per MWh")
    
    pl.savefig("./pic/"+str(pathToPic) + "/curvesFromCluster." + picFormat, format=picFormat)
    pl.close(fig)
Example #51
0
def psmc_figure(cum_change, tmrca, position, prefix):
    X, Y, Z, site, time = psmc_XYZ( prefix )
    fig = pl.figure(figsize=(24,7)) 
    pl.pcolor(X, Y, Z, vmin=0, vmax=0.15)    
    my_axes = fig.gca()
    #ylabels = ["%.4g" % (float(y)*2 * default_pop_size) for y in my_axes.get_yticks()]
    ylabels = ["%.4g" % (float(y)) for y in my_axes.get_yticks()]
    my_axes.set_yticklabels(ylabels)
    
    #pl.colorbar()   
    pl.step(cum_change, [x*2 for x in tmrca] , color = "red", linewidth=15.0) # becasue x is generated by ms, which is scaled to 4N0, psmc scale to 2N0. Thereofore, needs to multiply by 2
    #pl.step(cum_change, [x for x in tmrca] , color = "red", linewidth=5.0)    
    pl.plot(position, [0.9*max(time)]*len(position), "wo", markersize=15)
    pl.axis([0, max(site) , 0, max(time)])
    pl.title("PSMC heat map", fontsize=25)
    pl.xlabel("Sequence base", fontsize=20)
    #pl.ylabel("TMRCA (generation)")
    pl.ylabel("TMRCA (2N0)", fontsize=20)
    #my_axes.set_yticklabels([])
    #my_axes.set_xticklabels([])
    pl.savefig(prefix + "psmc_heat" + ".png", transparent=True)
    print "done"
    pl.close()
Example #52
0
def smcsmc_figure(cum_change, tmrca, position, prefix):
    X, Y, Z, site, time = smcsmc_XYZ( prefix )
    fig = pl.figure(figsize=(24,7)) 
    pl.pcolor(X, Y, Z, vmin=0, vmax=0.15)
    my_axes = fig.gca()
    ylabels = ["%.4g" % (float(y)+shifting) for y in my_axes.get_yticks()]
    my_axes.set_yticklabels(ylabels)
    
    #pl.colorbar()
    #pl.step(cum_change, [x*4*default_pop_size for x in tmrca] , color = "red", linewidth=5.0)
    pl.step(cum_change, tmrca , color = "red", linewidth=15.0)
    pl.plot(position, [0.9*max(time)]*len(position), "wo", markersize=15)    
    
    pl.axis([min(site), max(site) , 0, max(time)])
    pl.axis([min(site), max(site) , shifting, max(time)])  # for the case of split
    #my_axes.set_yticklabels([])
    #my_axes.set_xticklabels([])
    pl.title("PFPSMC heat map", fontsize=25)
    pl.xlabel("Sequence base", fontsize=20)
    #pl.ylabel("TMRCA (generation)")
    pl.ylabel("TMRCA (4N0)", fontsize=20)
    pl.savefig( prefix + "smcsmc_heat" + ".png", transparent=True)
    pl.close()
Example #53
0
File: column.py Project: pism/pism
def errors_advection_down(plot_results=True, T_final=1000.0, dt=100, Mz=101):
    """Test the enthalpy solver using a 'pure advection' problem with
    Neumann (in-flow) B.C. at the surface.

    We use Dirichlet B.C. at the base but they are irrelevant due
    to upwinding.
    """
    w = -1.0

    config.set_double("constants.ice.thermal_conductivity", 0.0)
    column = EnthalpyColumn(Mz, dt)
    config.set_double("constants.ice.thermal_conductivity", k)

    Lz = column.Lz
    z = np.array(column.sys.z())

    E_exact, dE_exact = exact_advection(Lz, w)

    with PISM.vec.Access(nocomm=[column.enthalpy,
                                 column.u, column.v, column.w,
                                 column.strain_heating]):
        column.sys.fine_to_coarse(E_exact(z, 0), 1, 1, column.enthalpy)
        column.reset_flow()
        column.w.set(w)
        column.reset_strain_heating()

        t = 0.0
        while t < T_final:
            column.init_column()

            column.sys.set_basal_dirichlet_bc(E_exact(0, t+dt))
            column.sys.set_surface_neumann_bc(dE_exact(Lz, t+dt))

            x = column.sys.solve()

            column.sys.fine_to_coarse(x, 1, 1, column.enthalpy)

            t += dt

    if plot_results:
        plt.figure()
        plt.xlabel("z, meters")
        plt.ylabel("E, J/kg")
        plt.step(z, E_exact(z, 0), color="blue", label="initial condition")
        plt.step(z, E_exact(z, t), color="green", label="exact solution")
        plt.grid(True)

        plt.step(z, x, label="T={} seconds".format(t), color="red")

        plt.legend(loc="best")

    errors = E_exact(z, t) - x

    max_error = np.max(np.fabs(errors))
    avg_error = np.average(np.fabs(errors))

    return max_error, avg_error
Example #54
0
def plotStep(data, Daily_Total, Hrs, k):
    import pylab
    import matplotlib.pyplot as plt
    import numpy

    data.sort(['Hr_Length'], inplace = True, ascending=[True])
    data.cumSpec = numpy.cumsum(data['Total_Specimens'])

    x = data.Hr_Length
    y = data.cumSpec
    
    pylab.figure(figsize=(12, 9)) 
    ax = pylab.subplot(111)  
    ax.spines["top"].set_visible(False)  
    ax.spines["right"].set_visible(False)
    ax.get_xaxis().tick_bottom()  
    ax.get_yaxis().tick_left()
    
    pylab.xticks(fontsize=14)  
    pylab.yticks(fontsize=14)
    pylab.xlim(0,Hrs + 1)
    
    pylab.xlabel("Hours", fontsize=16)  
    pylab.ylabel("Total Specimens", fontsize=16) 
    pylab.title("Daily Specimens Deliveries", fontsize=20)  
    
 
    pylab.step(x, y , color="#F0501A", lw=2.0, label="Actual Deliveries")
    pylab.plot([0,Hrs], [0,Daily_Total], color = "#3F5D7D", lw=2.0, label = 'Hypothetical Constant Flow')
    
    pylab.legend(loc='upper left')
    pylab.text(11, 450, "Cluster Size = %i"%k, fontsize=10)  
       
    pylab.savefig('Step_Plot_clustersize_%i.png'%k, bbox_inches="tight");  
 
    plot = pylab.show()
    return plot
Example #55
0
def archive(objname):

    corrname = "std-correction.npy"
    if not os.path.isfile(corrname):
        corrname = '/scr2/npk/sedm/OUTPUT/2015mar25/std-correction.npy'

    ss = np.load(specname)[0]
    corr = np.load(corrname)[0]

    corr = np.load('atm-corr.npy')[0]
    corf = interp1d(corr['nm'],
                    corr['correction'],
                    bounds_error=False,
                    fill_value=1.0)

    ec = 0
    ext = None
    if ss.has_key('extinction_corr'):
        ext = ss['extinction_corr']
        ec = np.median(ext)
    elif ss.has_key('extinction_corr_A'):
        ext = ss['extinction_corr_A']
        ec = np.median(ext)

    et = ss['exptime']
    pl.title("%s\n(airmass corr factor ~ %1.2f Exptime: %i)" %
             (specname, ec, et))
    pl.xlabel("Wavelength [nm]")
    pl.ylabel("erg/s/cm2/ang")

    pl.step(ss['nm'], ss['ph_10m_nm'] * corf(ss['nm']), linewidth=2)
    try:
        pl.step(ss['skynm'], ss['skyph'] * corf(ss['skynm']))
    except:
        pl.step(ss['nm'],
                ss['skyph'] * (ss['N_spaxA'] + ss['N_spaxB']) * corf(ss['nm']))

    try:
        pl.step(ss['nm'], np.sqrt(np.abs(ss['var'])) * corf(ss['nm']))
    except:
        pass

    pl.legend(['obj', 'sky', 'err'])
    pl.xlim(360, 1100)
    pl.grid(True)
    pl.ion()
    pl.show()
Example #56
0
def test_fused_lasso(n=100,l1=2.,**control):

    D = (np.identity(n) - np.diag(np.ones(n-1),-1))[1:]
    M = np.linalg.eigvalsh(np.dot(D.T, D)).max() 

    Y = np.random.standard_normal(n)
    Y[int(0.1*n):int(0.3*n)] += 6.

    p1 = signal_approximator((D, Y),L=M)
    p1.assign_penalty(l1=l1)
    
    p2 = glasso.generalized_lasso((np.identity(n), D, Y),L=M)
    p2.assign_penalty(l1=l1)
    
    t1 = time.time()
    opt1 = regreg.FISTA(p1)
    opt1.fit(tol=control['tol'], max_its=control['max_its'])
    t2 = time.time()
    ts1 = t2-t1

    t1 = time.time()
    opt2 = regreg.FISTA(p2)
    opt2.fit(tol=control['tol'], max_its=control['max_its'])
    t2 = time.time()
    ts2 = t2-t1

    beta1, _ = opt1.output
    beta2, _ = opt2.output
    X = np.arange(n)

    print (np.fabs(beta1-beta2).sum() / np.fabs(beta1).sum())
    if control['plot']:
        pylab.clf()
        pylab.step(X, beta1, linewidth=3, c='red')
        pylab.step(X, beta2, linewidth=3, c='blue')
        pylab.scatter(X, Y)
        pylab.show()
Example #57
0
def plot_initial_and_optimized_controls(time_points, \
    udata_init, udata_opt, umin, umax):

    pl.rc("text", usetex = True)
    pl.rc("font", family="serif")

    pl.subplot2grid((2, 1), (0, 0))
    pl.step(time_points[:-1], udata_init[:,0], label = "$\delta_{init}$")
    pl.step(time_points[:-1], udata_init[:,1], label = "$D_{init}$")

    pl.plot([time_points[0], time_points[-2]], [umin[0], umin[0]], \
        color = "b", linestyle = "dashed", label = "$\delta_{min}$")
    pl.plot([time_points[0], time_points[-2]], [umax[0], umax[0]], \
        color = "b", linestyle = "dotted", label = "$\delta_{max}$")

    pl.plot([time_points[0], time_points[-2]], [umin[1], umin[1]], \
        color = "g", linestyle = "dashed", label = "$D_{min}$")
    pl.plot([time_points[0], time_points[-2]], [umax[1], umax[1]], \
        color = "g", linestyle = "dotted", label = "$D_{max}$")

    pl.ylabel("$\delta,\,D$", rotation = 0)
    pl.ylim(-0.6, 1.1)
    pl.title("Initial and optimized controls")
    pl.legend(loc = "upper right")

    pl.subplot2grid((2, 1), (1, 0))
    pl.step(time_points[:-1], udata_opt[:,0], label = "$\delta_{opt,coll}$")
    pl.step(time_points[:-1], udata_opt[:,1], label = "$D_{opt,coll}$")

    pl.plot([time_points[0], time_points[-2]], [umin[0], umin[0]], \
        color = "b", linestyle = "dashed", label = "$\delta_{min}$")
    pl.plot([time_points[0], time_points[-2]], [umax[0], umax[0]], \
        color = "b", linestyle = "dotted", label = "$\delta_{max}$")

    pl.plot([time_points[0], time_points[-2]], [umin[1], umin[1]], \
        color = "g", linestyle = "dashed", label = "$D_{min}$")
    pl.plot([time_points[0], time_points[-2]], [umax[1], umax[1]], \
        color = "g", linestyle = "dotted", label = "$D_{max}$")

    pl.xlabel("$t$")
    pl.ylabel("$\delta,\,D$", rotation = 0)
    pl.ylim(-0.6, 1.1)
    pl.legend(loc = "upper right")

    pl.show()
Example #58
0
def myplot_hist(x,y,xlim=None,ylim=None, symbol=None,alpha=1, offset=0, fig = None, fcolor=None, ax=None, nbins=None):

    if symbol:
        color=symbol[:-1]
        marker=symbol[-1]
        if not fcolor:
            fcolor=color
    else:
        color = 'blue'
        marker='o'
        fcolor=color
    if fig:
        pl.figure(fig)
#    print "from myplot_err:",symbol,xlim,ylim
    if xlim :
        pl.xlim(xlim)
    if ylim :
        pl.ylim(ylim)
    print xlim,ylim,x,y
    if not symbol :
        symbol='ko'
    print nbins
    if nbins is None:
        nbins=int((xlim[1]-xlim[0])/10)
    else:
        nbins=int((xlim[1]-xlim[0])/nbins)
    print nbins
    print xlim[0],xlim[1], np.asarray(x),np.asarray(y),nbins,ax
    print "\n\n\n"
    
    X,Y,Ystd=binMeanStdPlot(np.asarray(x),np.asarray(y),numBins=nbins,xmin=xlim[0],xmax=xlim[1], ax=ax)
    
    pl.errorbar(X,Y+offset, yerr=Ystd, fmt=None,color=color, ecolor=color,alpha=alpha)
    pl.errorbar(X,Y+offset, yerr=Ystd, fmt='.',color=color, ecolor=color,alpha=alpha)
    try:
        binsz=X[1]-X[0]
    except:
        binsz=0
    newx=[]
    newy=[]
    newx=[newx+[x,x] for x in X-binsz/2]
    newx =np.asarray(newx).flatten()[1:]

    newy=[newy+[y,y] for y in (Y)]
    newy=np.asarray(newy).flatten()
    newx=np.insert(newx,len(newx),newx[-1]+binsz)
    return pl.step(newx,np.asarray(newy)+offset,"",alpha=alpha,color=color)
Example #59
0
def normplot(a, outp):
	
	''' Plots histograms describing the PDF and CDF corresponding to a 1-D array of data and saves the figure as a PNG file. '''

	# Regular expression that determines the input filename minus the extension to use as the base for the figure filename.
	name_base = re.search(r'\b(.+)\b\.', outp)

	# Set the figure size and generate the PDF plot canvas.
	fig = plt.figure(figsize=(12, 6))
	p = plt.subplot(121)

	# Determine how many normality tests were passed.
	count = normtest(a)
	
	# If 2 or more of the 4 normality tests are passed, decide that data is normally distributed; otherwise, decide that it is not.
	if count >= 2:
		p.set_title('PDF\n(Data appears to be normal...)', fontsize=12)
	elif count < 2:
		p.set_title('PDF\n(Data doesn\'t appear to be normal...)', fontsize=12)

	# Add labels to the PDF plot.
	p.set_xlabel('K-eff')
	p.set_ylabel('Frequency')

	# Plot a histogram of the data (the PDF).
	count, bins, ignored = plt.hist(a, normed=True, histtype='stepfilled', alpha=0.5)

	mu = numpy.mean(a)
	sigma = numpy.std(a)
	plt.step(bins, 1/(sigma * numpy.sqrt(2 * numpy.pi)) * numpy.exp( - (bins - mu)**2 / (2 * sigma**2) ), linewidth=2, color='g')
	
	# Generate the CDF plot canvas and add labels.
	p = plt.subplot(122) 
	p.set_title('CDF', fontsize=12)
	p.set_xlabel('K-eff')
	p.set_ylabel('Frequency') 
	
	# Plot a histogram of the data (the CDF).
	#h = plt.hist(a, histtype='step', cumulative=True, normed=True, bins=100)
	ecdf = sm.distributions.ECDF(a)
	x = numpy.linspace(min(a), max(a))
	y = ecdf(x)
	plt.step(x, y)

	s = numpy.random.normal(mu, sigma, 10000)
	ecdf = sm.distributions.ECDF(s)
	x = numpy.linspace(min(a), max(a))
	y = ecdf(x)
	plt.step(x, y)

	#plt.show()

	# Save the figure of the PDF and CDF plots as a PNG file with the input file name.
	plt.savefig(name_base.group(1) + '_pdf_cdf.png', bbox_inches='tight')