def plot_spectrograms(bsl,rec,rate,title):
    plt.close()
    fig, ax = plt.subplots(nrows=9, ncols=2, sharex='col', sharey='row')
    plt.subplots_adjust(wspace = .05,hspace = 0.4 )
    ny_nfft=1024
    i=0
    while i<9:
        Pxx, freq, bins, im = ax[i,0].specgram(bsl[i],NFFT=ny_nfft,Fs=rate)
        ax[i,0].set_ylim([0, 40])
        if(i==8):
            ax[i,0].set_xlabel("Time, seconds")
        ax[i,0].set_ylabel("Freq, Hz")
        ax[i,0].set_title(title+' baseline sleep, REM stage, Channel:'+str(i+1))
        i=i+1
    i=0
    while i<9:
        Pxx, freq, bins, im = ax[i,1].specgram(rec[i],NFFT=ny_nfft,Fs=rate)
        #ax[i,1].ylim(0,40)
        ax[i,1].set_ylim([0, 40])
        #ax[i,1].set_xlim([0, 10000]) #13000])
        if(i==8):
            ax[i,1].set_xlabel("Time, seconds")
        #ax[i,1].set_ylabel("Freq, Hz")
        ax[i,1].set_title(title+'   recovery sleep, REM stage, Channel:'+str(i+1))
        i=i+1
    plt.show()
    return
Beispiel #2
0
def plot_setup_post(figure_number = None, show = True, save_file = None,
					legend = True, legend_location = 0):
	"""
	Handles post-figure setup, including legends, file saving (save_file is
	desired filename), showing the figure, and clearing it.
	"""

	if figure_number:
		pyp.figure(figure_number)

	pyp.subplots_adjust(bottom=.5) # adjustment to give more xlabel space

	# change limits
	# pyp.xlim( xmin = 0, xmax = 10000 )
	# pyp.ylim( ymin = 0, ymax = 10000 )
	# pyp.ylim( (0,10000) ) # equivalent to the line above

	if legend:
		pyp.legend(loc = legend_location)
	if save_file:
		pyp.savefig(save_file)
	if show:
		pyp.show()
	else:
		pyp.clf() # clears figure if not plotted
Beispiel #3
0
def paired_boxplot_o(boxes):
    """
    Wrapper around plt.boxplot to draw paired boxplots
    for a set of boxes. 
    
    Input is the same as plt.boxplot:
        Array or a sequence of vectors.
    """
    fig = plt.figure(figsize=(len(boxes) / 2.5, 4))
    ax1 = fig.add_subplot(111)
    plt.subplots_adjust(left=0.075, right=0.95, top=0.9, bottom=0.25)
    bp = ax1.boxplot(boxes, notch=0, positions=np.arange(len(boxes)) + 
                     1.5 * (np.arange(len(boxes)) / 2), patch_artist=True)
    [p.set_color(colors[0]) for p in bp['boxes'][::2]]
    [p.set_color('black') for p in bp['whiskers']]
    [p.set_color('black') for p in bp['fliers']]
    [p.set_alpha(.4) for p in bp['fliers']]
    [p.set_alpha(.6) for p in bp['boxes']]
    [p.set_edgecolor('black') for p in bp['boxes']]
    ax1.yaxis.grid(True, linestyle='-', which='major', color='lightgrey',
                  alpha=0.5)
    
    # Hide these grid behind plot objects
    ax1.set_axisbelow(True)
    ax1.set_ylabel('$Log_{2}$ RNA Expression')
    ax1.set_xticks(3.5 * np.arange(len(boxes) / 2) + .5)
    return ax1, bp
Beispiel #4
0
def display_collision3D(collision):

    jets,muons,electrons,photons,met = collision

    lines = draw_beams()

    pmom = np.array(jets).transpose()[1:4].transpose()
    origin = np.zeros((len(jets),3))
    lines += draw_jet3D(origin=origin,pmom=pmom)

    pmom = np.array(muons).transpose()[1:4].transpose()
    origin = np.zeros((len(muons),3))
    lines += draw_muon3D(origin=origin,pmom=pmom)

    pmom = np.array(electrons).transpose()[1:4].transpose()
    origin = np.zeros((len(electrons),3))
    lines += draw_electron3D(origin=origin,pmom=pmom)

    pmom = np.array(photons).transpose()[1:4].transpose()
    origin = np.zeros((len(photons),3))
    lines += draw_photon3D(origin=origin,pmom=pmom)

    fig = plt.figure(figsize=(6,4),dpi=100)
    ax = fig.add_subplot(1,1,1)
    ax = fig.gca(projection='3d')
    plt.subplots_adjust(top=0.98,bottom=0.02,right=0.98,left=0.02)

    for l in lines:
        ax.add_line(l)

    ax.set_xlim(-200,200)
    ax.set_ylim(-200,200)
    ax.set_zlim(-200,200)
Beispiel #5
0
	def plot_scatter(self, iclus):
		observed = rfn.read_data()
		fig = plt.figure(2)
		plt.clf()

		trueM = observed[iclus*self.nlos, 1]
		mass = observed[iclus*self.nlos:(iclus+1)*self.nlos, 2:]
		mass, masstype = self.get_valid_array_altogether(mass, trueM)

		ii = 0
		for iobs in xrange(self.nobs):
			for jobs in xrange(iobs+1, self.nobs, 1):

				ax = fig.add_subplot(4, 3, ii+1)
				ax.plot(mass[:, iobs], mass[:, jobs], 'bo', ms=2.5)

				plt.subplots_adjust(**self.adjustparam)
				ax.xaxis.set_major_locator(plt_ticker.MaxNLocator(3))
				ax.yaxis.set_major_locator(plt_ticker.MaxNLocator(3))

				#ax.set_xlabel("%s/<%s>" % (self.obsname[iobs], self.obsname[iobs])) 
				#ax.set_ylabel("%s/<%s>" % (self.obsname[jobs], self.obsname[jobs])) 

				fontsize=9
				for tick in ax.xaxis.get_major_ticks():
					tick.label1.set_fontsize(fontsize)
				for tick in ax.yaxis.get_major_ticks():
					tick.label1.set_fontsize(fontsize)

				ii += 1
				print self.obsname[iobs], self.obsname[jobs]

		plt.savefig(os.path.join("paper", "figure", "scatter_%s_clus%d.eps" % (masstype, iclus)), orientation='portrait', transparent=True)
Beispiel #6
0
    def run(self):
        lines = open(self.inFilename).readlines()
        data = []

        for line in lines:
            data.append(float(line.strip()))
        x = np.asarray(data)
        fig = plt.figure(figsize=(7, 3))        
     
        ax = fig.add_subplot(111)
        plt.subplots_adjust(left = 0.15, bottom = 0.15, wspace = 0)
        plt.xlabel(self.options.xlab)
       
        
        plt.ylabel(self.options.ylab)
        if self.options.logy == True:
            ax.set_yscale('log')
        plt.title(self.options.title)
        if self.options.plotType == 'hist':
            plt.xlim(0,x.max())
            n,bins,patches = plt.hist(x, self.options.bins,  histtype='bar',
                                 color=['crimson'],normed=False, alpha=0.85)
        else:
            plt.xlim(0,x.size)
            line, = plt.plot(range(x.size), x, 'r-', label = self.options.label)
        if self.options.label:
            ax.legend()
        plt.savefig(self.outFilename)
    def draw(self, description=None, ofile="test.png"):

        plt.clf()

        for f in self.funcs:
            f()

        plt.axis("off")

        ax = plt.gca()
        ax.set_aspect("equal", "datalim")

        f = plt.gcf()
        f.set_size_inches(12.8, 7.2)

        if description is not None:
            plt.text(0.025, 0.05, description, transform=f.transFigure)

        if self.xlim is not None:
            plt.xlim(*self.xlim)

        if self.ylim is not None:
            plt.ylim(*self.ylim)

        plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)

        # dpi = 100 for 720p, 150 for 1080p
        plt.savefig(ofile, dpi=150)
Beispiel #8
0
def plot_spectrograms(data, rate, subject, condition):
    """
    Creates spectrogram subplots for all 9 channels
    """
    fig = plt.figure()   
   # common title
    fname = 'Spectrogram - '+'Subject #'+subject+' '+condition+' Dataset'
    fig.suptitle(fname, fontsize=14, fontweight='bold')            
    # common ylabel
    fig.text(0.06, 0.5, 'ylabel', 
             ha='center', va='center', rotation='vertical',
             fontsize=14, fontweight='bold')
    # use this to stack EEG, EOG, EMG on top of each other         
    sub_order = [1,4,7,10,2,5,3,6,9]          
    
    for ch in range(0, len(data)):
        plt.subplot(4, 3, sub_order[ch])
        plt.subplots_adjust(hspace=.6)  # adds space between subplots
        plt.title(channel_name[ch])    
        Pxx, freqs, bins, im = plt.specgram(data[ch],NFFT=512,Fs=rate)       
        plt.ylim(0,70)
        plt.xlabel('Time (Seconds)')
        plt.ylabel('Frequency (Hz)')
    
    #fig.savefig(fname+'.pdf', format='pdf')  buggy resolution problem
    return
Beispiel #9
0
def plot_data(tag):
    data_array = tag.references[0]
    voltage = np.zeros(data_array.data.shape)
    data_array.data.read_direct(voltage)

    x_axis = data_array.dimensions[0]
    time = x_axis.axis(data_array.data_extent[0])

    spike_times = tag.positions[:]

    feature_data_array = tag.features[0].data
    snippets = tag.features[0].data[:]
    single_snippet = tag.retrieve_feature_data(3, 0)[:]

    snippet_time_dim = feature_data_array.dimensions[1]
    snippet_time = snippet_time_dim.axis(feature_data_array.data_extent[1])

    response_axis = plt.subplot2grid((2, 2), (0, 0), rowspan=1, colspan=2)
    single_snippet_axis = plt.subplot2grid((2, 2), (1, 0), rowspan=1, colspan=1)
    average_snippet_axis = plt.subplot2grid((2, 2), (1, 1), rowspan=1, colspan=1)

    response_axis.plot(time, voltage, color="dodgerblue", label=data_array.name)
    response_axis.scatter(spike_times, np.ones(spike_times.shape) * np.max(voltage), color="red", label=tag.name)
    response_axis.set_xlabel(x_axis.label + ((" [" + x_axis.unit + "]") if x_axis.unit else ""))
    response_axis.set_ylabel(data_array.label + ((" [" + data_array.unit + "]") if data_array.unit else ""))
    response_axis.set_title(data_array.name)
    response_axis.set_xlim(0, np.max(time))
    response_axis.set_ylim((1.2 * np.min(voltage), 1.2 * np.max(voltage)))
    response_axis.legend()

    single_snippet_axis.plot(snippet_time, single_snippet.T, color="red", label=("snippet No 4"))
    single_snippet_axis.set_xlabel(
        snippet_time_dim.label + ((" [" + snippet_time_dim.unit + "]") if snippet_time_dim.unit else "")
    )
    single_snippet_axis.set_ylabel(
        feature_data_array.label + ((" [" + feature_data_array.unit + "]") if feature_data_array.unit else "")
    )
    single_snippet_axis.set_title("single stimulus snippet")
    single_snippet_axis.set_xlim(np.min(snippet_time), np.max(snippet_time))
    single_snippet_axis.set_ylim((1.2 * np.min(snippets[3, :]), 1.2 * np.max(snippets[3, :])))
    single_snippet_axis.legend()

    mean_snippet = np.mean(snippets, axis=0)
    std_snippet = np.std(snippets, axis=0)
    average_snippet_axis.fill_between(
        snippet_time, mean_snippet + std_snippet, mean_snippet - std_snippet, color="red", alpha=0.5
    )
    average_snippet_axis.plot(snippet_time, mean_snippet, color="red", label=(feature_data_array.name + str(4)))
    average_snippet_axis.set_xlabel(
        snippet_time_dim.label + ((" [" + snippet_time_dim.unit + "]") if snippet_time_dim.unit else "")
    )
    average_snippet_axis.set_ylabel(
        feature_data_array.label + ((" [" + feature_data_array.unit + "]") if feature_data_array.unit else "")
    )
    average_snippet_axis.set_title("spike-triggered average")
    average_snippet_axis.set_xlim(np.min(snippet_time), np.max(snippet_time))
    average_snippet_axis.set_ylim((1.2 * np.min(mean_snippet - std_snippet), 1.2 * np.max(mean_snippet + std_snippet)))

    plt.subplots_adjust(left=0.15, top=0.875, bottom=0.1, right=0.98, hspace=0.35, wspace=0.25)
    plt.show()
Beispiel #10
0
def plot_transition(df1, df2):
    """
    plot stage transitions
    df1: normal sleep (df1 = analyse(base))
    df2: sleep depravation (df2 = analyse(depr))
    """    
    N = 5
    ind = np.arange(N)  # the x locations for the groups
    width = 0.2       # the width of the bars
    plt.close()

    fig, ax = plt.subplots(nrows=6, ncols=6, sharex='col', sharey='row')
    plt.subplots_adjust(wspace = 0.2,hspace = 0.4 )
    for i in range(0,6): # do not care about stage transitions > 5
        for j in range(0,6):     
            clef = 't' + str(i) + '-' + str(j)
            normal = df1[clef].tolist()
            mean = sum(normal) / len(normal)
            normal.extend([mean])
            rects1 = ax[i,j].bar(ind, normal, width, color='r')
            depravation = df2[clef].tolist()
            mean = sum(depravation) / len(depravation)
            depravation.extend([mean])
            rects2 = ax[i,j].bar(ind+width, depravation, width, color='y')
            ax[i,j].set_title('t' + str(i) + '-' + str(j))
            ax[i,j].set_xticks(ind+width)
            ax[i,j].set_xticklabels( ('1', '2', '3', '4', 'Avg') )
Beispiel #11
0
 def segmentation(self, threshold):
     img = self.spectrogram["data"]
     mask = (img > threshold).astype(np.float)
     hist, bin_edges = np.histogram(img, bins=60)
     bin_centers = 0.5*(bin_edges[:-1] + bin_edges[1:])
     binary_img = mask > 0.5
     plt.figure(figsize=(11,8))
     plt.subplot(131)
     plt.imshow(img)
     plt.axis('off')
     plt.subplot(132)
     plt.plot(bin_centers, hist, lw=2)
     print(threshold)
     plt.axvline(threshold, color='r', ls='--', lw=2)
     plt.text(0.57, 0.8, 'histogram', fontsize=20, transform = plt.gca().transAxes)
     plt.text(0.45, 0.75, 'threshold = '+ str(threshold)[0:5], fontsize=15, transform = plt.gca().transAxes)
     plt.yticks([])
     plt.subplot(133)     
     plt.imshow(binary_img)
     plt.axis('off')
     plt.subplots_adjust(wspace=0.02, hspace=0.3, top=1, bottom=0.1, left=0, right=1)
     plt.show()
     print(img.max())
     print(binary_img.max())
     
     return mask
Beispiel #12
0
def SVD_plot(SVStreams, SValues, stachans, title=False):
    r"""Function to plot the singular vectors from the clustering routines, one\
    plot for each stachan

    :type SVStreams: list of :class:Obspy.Stream
    :param SVStreams: See clustering.SVD_2_Stream - will assume these are\
            ordered by power, e.g. first singular vector in the first stream
    :type SValues: list of float
    :param SValues: List of the singular values corresponding to the SVStreams
    :type stachans: list
    :param stachans: List of station.channel
    """
    for stachan in stachans:
        print(stachan)
        plot_traces = [SVStream.select(station=stachan.split('.')[0],
                                       channel=stachan.split('.')[1])[0]
                       for SVStream in SVStreams]
        fig, axes = plt.subplots(len(plot_traces), 1, sharex=True)
        axes = axes.ravel()
        for i, tr in enumerate(plot_traces):
            y = tr.data
            x = np.linspace(0, len(y) * tr.stats.delta, len(y))
            axes[i].plot(x, y, 'k', linewidth=1.1)
            ylab = 'SV '+str(i+1)+'='+str(round(SValues[i] / len(SValues), 2))
            axes[i].set_ylabel(ylab, rotation=0)
            axes[i].yaxis.set_ticks([])
            print(i)
        axes[-1].set_xlabel('Time (s)')
        plt.subplots_adjust(hspace=0)
        if title:
            axes[0].set_title(title)
        else:
            axes[0].set_title(stachan)
        plt.show()
    return
Beispiel #13
0
def plot_transition_ratio(df1, df2):
    """
    plot stage transitions
    df1: normal sleep (df1 = analyse(base))
    df2: sleep depravation (df2 = analyse(depr))
    """    
    N = 5
    ind = np.arange(N)  # the x locations for the groups
    width = 0.2       # he width of the bars
    plt.close()
    plt.rc('font', family='Arial')

    fig, ax = plt.subplots(nrows=6, ncols=6, sharex='col', sharey='row')
    fig.suptitle("Comparison of the number of stage transitions (% of total transitions) (origin stage " + u'\u2192' + " dest. stage)", fontsize=20)        
    plt.subplots_adjust(wspace = 0.2,hspace = 0.4 )
    for i in range(0,6): # do not care about stage transitions > 5
        for j in range(0,6):     
            clef = '%t' + str(i) + '-' + str(j)
            normal = df1[clef].tolist()
            mean = sum(normal) / len(normal)
            normal.extend([mean])
            rects1 = ax[i,j].bar(ind, normal, width, color='b')
            depravation = df2[clef].tolist()
            mean = sum(depravation) / len(depravation)
            depravation.extend([mean])
            rects2 = ax[i,j].bar(ind+width, depravation, width, color='r')
            for label in (ax[i,j].get_xticklabels() + ax[i,j].get_yticklabels()):
                label.set_fontname('Arial')
                label.set_fontsize(8)            
            ax[i,j].set_title(str(i) + ' ' + u'\u2192' + ' ' + str(j))
            ax[i,j].set_xticks(ind+width)
            ax[i,j].set_xticklabels( ('1', '2', '3', '4', 'Avg') )
            ax[i,j].set_yticks(np.arange(0, 6, 2))
            ax[i,j].set_ylim([0,6])
    fig.legend( (rects1[0], rects2[0]), ('Baseline', 'Recovery'), loc = 'lower right', fontsize=10)
def doit():
    # test it out

    L = 1

    R = 10

    theta = np.radians(np.arange(0,361))

    # draw a circle
    plt.plot(R*np.cos(theta), R*np.sin(theta), c="b")


    # draw some people
    angles = [30, 60, 90, 120, 180, 270, 300]

    for l in angles:
        center = ( (R + 0.5*L)*np.cos(np.radians(l)),
                   (R + 0.5*L)*np.sin(np.radians(l)) )
        draw_person(center, L, np.radians(l - 90), color="r")
        L = 1.1*L

    plt.axis("off")

    ax = plt.gca()
    ax.set_aspect("equal", "datalim")


    plt.subplots_adjust(left=0.05, right=0.98, bottom=0.05, top=0.98)
    plt.axis([-1.2*R, 1.2*R, -1.2*R, 1.2*R])

    f = plt.gcf()
    f.set_size_inches(6.0, 6.0)

    plt.savefig("test.png")
def plot_time_domain_waveform(fig, waveform, imag=False, mag=False, 
                              xlim=None, xlabel=r'$tc^3/GM$',
                              ylabel_pol=r'$h_+ + i h_\times$', 
                              ylabel_amp=r'$A$', ylabel_phase=r'$\Phi$', 
                              pol_legend=True, wave_legend=False):
    """Plot the amplitude, phase, and polarizations of a waveform.
    """
    # Polarization plot
    axes = fig.add_subplot(311)
    t = waveform.time
    hcomp = waveform.get_complex()
    label = r'$h_+$' if pol_legend else ''
    line_list = axes.plot(t, hcomp.real, ls='-', label=label)
    color = line_list[0].get_color()
    if imag:
        label = r'$h_\times$' if pol_legend else ''
        axes.plot(t, hcomp.imag, ls='--', c=color, label=label)
    if mag:
        label = r'$|h_+ + ih_\times|$' if pol_legend else ''
        axes.plot(waveform.time, waveform.amp, ls=':', c=color, label=label)
    
    if xlim is not None: axes.set_xlim(xlim)
    axes.set_ylabel(ylabel_pol, fontsize=16)
    axes.set_xticklabels(axes.get_xticks(), fontsize=14)
    axes.set_yticklabels(axes.get_yticks(), fontsize=14)
    axes.minorticks_on()
    axes.tick_params(which='major', width=2, length=8)
    axes.tick_params(which='minor', width=2, length=4)
    axes.xaxis.set_major_formatter(NullFormatter()) # get rid of x-axis numbers
    axes.legend(fontsize=14, loc='best', ncol=3)    
    
    # Amplitude plot
    axes = fig.add_subplot(312)
    axes.plot(waveform.time, waveform.amp, c=color)
    
    if xlim is not None: axes.set_xlim(xlim)
    axes.set_ylabel(ylabel_amp, fontsize=16)
    axes.set_xticklabels(axes.get_xticks(), fontsize=14)
    axes.set_yticklabels(axes.get_yticks(), fontsize=14)
    axes.minorticks_on()
    axes.tick_params(which='major', width=2, length=8)
    axes.tick_params(which='minor', width=2, length=4)
    axes.xaxis.set_major_formatter(NullFormatter()) # get rid of x-axis numbers
    
    # Phase plot
    axes = fig.add_subplot(313)
    label = wave_legend if wave_legend is not False else ''
    axes.plot(waveform.time, waveform.phase, c=color, label=label)

    if xlim is not None: axes.set_xlim(xlim)
    axes.set_xlabel(xlabel, fontsize=16)
    axes.set_ylabel(ylabel_phase, fontsize=16)
    axes.set_xticklabels(axes.get_xticks(), fontsize=14)
    axes.set_yticklabels(axes.get_yticks(), fontsize=14)
    axes.minorticks_on()
    axes.tick_params(which='major', width=2, length=8)
    axes.tick_params(which='minor', width=2, length=4)
    axes.legend(fontsize=14, loc='best', ncol=2)
    
    subplots_adjust(hspace=0.07)
def plot_fits(direction_rates,fit_curve,title):
    """
    This function takes the x-values and the y-values  in units of spikes/s 
    (found in the two columns of direction_rates and fit_curve) and plots the 
    actual values with circles, and the curves as lines in both linear and 
    polar plots.
    """
    #print direction_rates
    
    
    
   # print fit_curve
   
    plt.subplots_adjust(hspace = 0.6)   
    y_max = np.max(direction_rates[:,1]) + 5
    plt.subplot(2,2,3)
    plt.axis([0,360,0,y_max])
    plt.plot(direction_rates[:,0], direction_rates[:,1],'o')
    plt.plot(fit_curve[:,0],fit_curve[:,1], '-')
    plt.xlabel("Direction of Motion (degrees)")
    plt.ylabel("Firing Rate (spikes/s)")
    plt.title(title)
    
    plt.subplot(2,2,4,  polar = True)    
    spikecounts = direction_rates[:,1]
    spikecounts2 = np.append(spikecounts, direction_rates[0,1]) 
    r = np.arange(0, 361, 45)*np.pi/180
    plt.polar(r, spikecounts2,'o')
    plt.polar(fit_curve[:,0]*np.pi/180,fit_curve[:,1],'-', label="Firing Rate (spikes/s)")
    plt.title(title)
    plt.legend(loc=8)
Beispiel #17
0
def plot_ratio_cormats():
	nprops = 19
	cormat_yn = N.loadtxt("cormat_to_do_pca.dat")
	cormat_jc = N.loadtxt("corrcoeff_jc.dat", usecols=[2])
	cormat_jc = cormat_jc.reshape(nprops, nprops)
	rat = cormat_yn/cormat_jc

	fig = plt.figure(1)
	plt.clf()
	plt.subplots_adjust(hspace=0.3, wspace=0.3)
	fontsize=8
	for ip in xrange(nprops): 
		ax = fig.add_subplot(4, 5, ip+1)
		ax.plot(N.arange(nprops), rat[ip, :], 'ro', ms=2.5)
		ax.xaxis.set_major_locator(plt_ticker.MaxNLocator(4))
		ax.yaxis.set_major_locator(plt_ticker.MaxNLocator(4))
		for tick in ax.xaxis.get_major_ticks():
			tick.label1.set_fontsize(fontsize)
		for tick in ax.yaxis.get_major_ticks():
			tick.label1.set_fontsize(fontsize)

		ii = N.where(N.abs(rat[ip, :]-1.) > 0.01)[0]
		print "-"*10
		print "{:d}: {:}".format(ip, ii)
		print cormat_yn[ip, ii]
		print cormat_jc[ip, ii]
Beispiel #18
0
def trace_plot(data, ylim):
    
    clf()
    plt.subplots_adjust(left=0.15);
    
    plt.subplot(411)
    plt.plot(np.arange(0,30000*180)/30000., data[0][:30000*3*60])
    plt.xticks(alpha = 0)
    plt.yticks(fontsize = 'large')
    plt.ylabel('Voltage (mV)', size = 'x-large')
    plt.ylim(ylim)
    
    plt.subplot(412)
    plt.plot(np.arange(0,30000*180)/30000.,data[1][:30000*3*60])
    plt.yticks(alpha = 0)
    plt.xticks(alpha = 0)
    plt.ylim(ylim)
    
    plt.subplot(413)
    plt.plot(np.arange(0,30000*180)/30000.,data[2][:30000*3*60])
    plt.xticks(alpha = 0)
    plt.yticks(alpha = 0)
    plt.ylim(ylim)
    
    plt.subplot(414)
    plt.plot(np.arange(0,30000*180)/30000., data[3][:30000*3*60])
    plt.xlabel('Time (s)', size = 'x-large')
    plt.xticks(fontsize = 'large')
    plt.yticks(alpha = 0)
    plt.ylim(ylim)
def plot_proj_scatter(pccoefs, eval, figname):
	"""
	plot scatters using the values projected on pc
	"""
	fig = plt.figure(4)
	plt.clf()

	eval /= N.sum(eval)

	param = dict(fontsize='small')
	
	range = N.max(N.abs(pccoefs))
	labelx = -0.15

	nplt = 4
	ncol = 3
	nrow = 2
	iplt = 1
	for iprops in xrange(nplt):
		for jprops in xrange(iprops+1, nplt):
			ax = fig.add_subplot(nrow, ncol, iplt)
			plt.subplots_adjust(hspace=0.2, wspace=0.25, left=0.08, right=0.95, bottom=0.08, top=0.9)
			ax.plot(pccoefs[:, iprops], pccoefs[:, jprops], 'ro', ms=3.)
			plt.axis('equal')
			#ax.set_xlim(-range, range)
			#ax.set_ylim(-range, range)
			ax.set_xlabel('PC%d(%.2f)' % (iprops, eval[iprops]), **param)
			ax.set_ylabel('PC%d(%.2f)' % (jprops, eval[jprops]), **param)
			ax.yaxis.set_label_coords(labelx, 0.5)
			iplt += 1

	plt.savefig(figname)
Beispiel #20
0
def animate_plot(w_dir=None, **kwargs):
    if w_dir == None: w_dir=os.getcwd()

    cdir = os.getcwd()
    files = []
    os.chdir(w_dir)
    os.system('mkdir j_movie')
    D0 = plp.pload(0,w_dir=w_dir)
    fig = plt.figure(num=1,figsize=[7,7])
    ax = fig.add_subplot(111)
    plt.subplots_adjust(left=0.1, bottom=0.15)
    frnum = kwargs.get('frames',plp.time_info(w_dir=w_dir)['time'])
    
    
    
    for i in [0,10,25,50,150,250,319,325,340,450,638]:  # 50 frames
        D = plp.pload(i,w_dir=w_dir)
        Ra = da.Rad_Average()
        xitem = D.x1
	yitem = D.x1*D.v3[:,32]
    #    yitem = Ra.Sigma(D,ul=1.0,urho=1.0e-9,Mstar=10.0,Gammae=5.0/3.0)
        ax.cla()
        
        
        

        if kwargs.get('pltype','normal') == 'normal':
            ax.plot(xitem,yitem,'k-')
        if kwargs.get('pltype','normal') == 'logx':
            ax.semilogx(xitem,yitem,'k-')
        if kwargs.get('pltype','normal') == 'logy':
            ax.semilogy(xitem,yitem,'k-')
        if kwargs.get('pltype','normal') == 'loglog':
            ax.loglog(xitem,yitem,'k-')

        ax.minorticks_on()
        ax.set_xlabel(kwargs.get('xlabel',r'XLabel'))
        ax.set_ylabel(kwargs.get('ylabel',r'YLabel'))
        ax.set_title(kwargs.get('title',r'Title'))
        
        
        #ax.text(90.0,1.3,r'$N_{\rm rot} = %04d$'%i)
        axcolor = 'white'
        axtime = plt.axes([0.1, 0.01, 0.8, 0.02], axisbg=axcolor)
        axtime.cla()
        stime = Slider(axtime, 'Nsteps', 0, frnum , valinit=D.time)

        #plt.draw()
        fname = w_dir+'j_movie/_tmp%03d.png'%i
        
        print 'Saving frame', fname
        fig.savefig(fname)
        files.append(fname)
        
    

    print 'Making movie animation.mpg - this make take a while'
    os.system("mencoder 'mf://j_movie/_tmp*.png' -mf type=png:fps=10 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o j_movie/animation.mpg")
    os.chdir(cdir)
Beispiel #21
0
def plot_synth_real(real_template, synthetic, channels=False):
    r"""Plot multiple channels of data for real data and synthetic.

    :type real_template: obspy.Stream
    :param real_template: Stream of the real template
    :type synthetic: obspy.Stream
    :param synthetic: Stream of synthetic template
    :type channels: list of str
    :param channels: List of tuples of (station, channel) to plot, default is\
            False, which plots all.
    """
    from obspy.signal.cross_correlation import xcorr
    from obspy import Stream
    colours = ['k', 'r']
    labels = ['Real', 'Synthetic']
    if channels:
        real = []
        synth = []
        for stachan in channels:
            real.append(real_template.select(station=stachan[0],
                                             channel=stachan[1]))
            synth.append(synthetic.select(station=stachan[0],
                                          channel=stachan[1]))
        real_template = Stream(real)
        synthetic = Stream(synth)

    # Extract the station and channels
    stachans = list(set([(tr.stats.station, tr.stats.channel)
                         for tr in real_template]))
    fig, axes = plt.subplots(len(stachans), 1, sharex=True, figsize=(5, 10))
    axes = axes.ravel()
    for i, stachan in enumerate(stachans):
        real_tr = real_template.select(station=stachan[0],
                                       channel=stachan[1])[0]
        synth_tr = synthetic.select(station=stachan[0],
                                    channel=stachan[1])[0]
        shift, corr = xcorr(real_tr, synth_tr, 2)
        print('Shifting by: '+str(shift)+' samples')
        if corr < 0:
            synth_tr.data = synth_tr.data * -1
            corr = corr * -1
        if shift < 0:
            synth_tr.data = synth_tr.data[abs(shift):]
            real_tr.data = real_tr.data[0:len(synth_tr.data)]
        elif shift > 0:
            real_tr.data = real_tr.data[abs(shift):]
            synth_tr.data = synth_tr.data[0:len(real_tr.data)]
        for j, tr in enumerate([real_tr, synth_tr]):
            y = tr.data
            y = y / float(max(abs(y)))
            x = np.linspace(0, len(y) * tr.stats.delta, len(y))
            axes[i].plot(x, y, colours[j], linewidth=2.0, label=labels[j])
            axes[i].get_yaxis().set_ticks([])
        ylab = stachan[0]+'.'+stachan[1]+' cc='+str(round(corr, 2))
        axes[i].set_ylabel(ylab, rotation=0)
    plt.subplots_adjust(hspace=0)
    # axes[0].legend()
    axes[-1].set_xlabel('Time (s)')
    plt.show()
Beispiel #22
0
def mso_orbit(orbit_number, res=60):
    o = mex.orbits[orbit_number]
    start = o.start
    finish = o.finish
    et = np.arange(start, finish, res)

    i = np.sum(et < o.periapsis)
    inbound = np.arange(0, i, 60)
    outbound = np.arange(i + 60, et.shape[0], 60)

    pos = mex.mso_position(et) / mex.mars_mean_radius_km
    lims = (-3, 3)
    off = 0.2
    plt.rcParams["font.size"] = 8

    phi = np.linspace(-np.pi, np.pi, 100)
    x = 0.78 + 0.96 * np.cos(phi) / (1 + 0.9 * np.cos(phi))
    y = 0.96 * np.sin(phi) / (1 + 0.9 * np.cos(phi))

    f = plt.figure(figsize=(8, 4))

    def panel(no, xn, yn, bs=True):
        plt.subplot(no, aspect="equal")
        if bs:
            plt.plot(x, y, "k--")
        plt.xlabel(xn + r"$ / R_M$")
        celsius.ylabel(yn + r"$ / R_M$", offset=off)
        plt.xlim(*lims)
        plt.ylim(*lims)
        plt.gca().add_patch(plt.Circle((0.0, 0.0), 1.0, fill=False))

    panel(141, r"$X$", r"$\rho$")
    plt.title("MEX ORBIT %d" % o.number)
    rho = np.sqrt(pos[1] ** 2.0 + pos[2] ** 2.0)
    plt.plot(pos[0], rho, "k-")
    plt.gca().add_patch(plt.Circle((0.0, 0.0), 1.0 + 1200.0 / mex.mars_mean_radius_km, fill=False, linestyle="dotted"))
    plt.gca().add_patch(plt.Circle((0.0, 0.0), 1.0 + 1500.0 / mex.mars_mean_radius_km, fill=False, linestyle="dotted"))
    plt.gca().add_patch(plt.Circle((0.0, 0.0), 1.0 + 2000.0 / mex.mars_mean_radius_km, fill=False, linestyle="dotted"))

    plt.plot(pos[0, inbound], rho[inbound], "ko")
    plt.plot(pos[0, outbound], rho[outbound], "ko", mfc="white")

    panel(142, r"$X$", r"$Z$")
    plt.plot(pos[0], pos[2], "k-")
    plt.plot(pos[0, inbound], pos[2, inbound], "ko")
    plt.plot(pos[0, outbound], pos[2, outbound], "ko", mfc="white")

    panel(143, r"$X$", r"$Y$")
    plt.plot(pos[0], pos[1], "k-")
    plt.plot(pos[0, inbound], pos[1, inbound], "ko")
    plt.plot(pos[0, outbound], pos[1, outbound], "ko", mfc="white")

    panel(144, r"$Y$", r"$Z$", bs=False)
    plt.plot(pos[1], pos[2], "k-")
    plt.plot(pos[1, inbound], pos[2, inbound], "ko")
    plt.plot(pos[1, outbound], pos[2, outbound], "ko", mfc="white")

    plt.subplots_adjust(wspace=0.3, right=0.96, top=0.94, bottom=0.07)
Beispiel #23
0
def fourcumplot(x1,x2,x3,x4,xmin,xmax,x1leg='$x_1$',x2leg='$x_2$',x3leg='$x_3$',x4leg='$x_3$',xlabel='',ylabel='$N(x>x\')$',fig=1,sharey=False,fontsize=12,bins1=50,bins2=50,bins3=50,bins4=50):
	"""
Script that plots the cumulative histograms of four variables x1, x2, x3 and x4
sharing the same X-axis. For each bin, Y is the fraction of the sample 
with values above X.

Arguments:

- x1,x2,x3,x4: arrays with data to be plotted
- xmin,xmax: lower and upper range of plotted values, will be used to set a consistent x-range
for both histograms.
- x1leg, x2leg, x3leg, x4leg: legends for each histogram	
- xlabel: self-explanatory.
- sharey: sharing the Y-axis among the histograms?
- bins1,bins2,...: number of bins in each histogram
- fig: which plot window should I use?

Inspired by `Scipy <http://www.scipy.org/Cookbook/Matplotlib/Multiple_Subplots_with_One_Axis_Label>`_.

v1 Jun. 2012: inherited from fourhists.
	"""
	pylab.rcParams.update({'font.size': fontsize})
	fig=pylab.figure(fig)
	pylab.clf()
	
	a=fig.add_subplot(4,1,1)
	if sharey==True:
		b=fig.add_subplot(4,1,2, sharex=a, sharey=a)
		c=fig.add_subplot(4,1,3, sharex=a, sharey=a)
		d=fig.add_subplot(4,1,4, sharex=a, sharey=a)
	else:
		b=fig.add_subplot(4,1,2, sharex=a)
		c=fig.add_subplot(4,1,3, sharex=a)		
		d=fig.add_subplot(4,1,4, sharex=a)
	
	a.hist(x1,bins1,label=x1leg,color='b',cumulative=-True,normed=True,histtype='stepfilled')
	a.legend(loc='best',frameon=False)
	a.set_xlim(xmin,xmax)
	
	b.hist(x2,bins2,label=x2leg,color='r',cumulative=-True,normed=True,histtype='stepfilled')
	b.legend(loc='best',frameon=False)

	c.hist(x3,bins3,label=x3leg,color='y',cumulative=-True,normed=True,histtype='stepfilled')
	c.legend(loc='best',frameon=False)

	d.hist(x4,bins4,label=x4leg,color='g',cumulative=-True,normed=True,histtype='stepfilled')
	d.legend(loc='best',frameon=False)
	
	pylab.setp(a.get_xticklabels(), visible=False)
	pylab.setp(b.get_xticklabels(), visible=False)
	pylab.setp(c.get_xticklabels(), visible=False)

	d.set_xlabel(xlabel)
	c.set_ylabel(ylabel)
	pylab.minorticks_on()
	pylab.subplots_adjust(hspace=0.15)
	pylab.draw()
	pylab.show()
def riemann():

    # grid info
    xmin = 0.0
    xmax = 1.0

    nzones = 2
    ng = 0

    gr = gp.FVGrid(nzones, xmin=xmin, xmax=xmax)


    #------------------------------------------------------------------------
    # plot a domain without ghostcells
    gr.draw_grid()

    gr.label_center(0, r"$i$", fontsize="medium")
    gr.label_center(1, r"$i+1$", fontsize="medium")

    gr.label_edge(1, r"$i+1/2$", fontsize="medium")


    plt.arrow(gr.xc[0]+0.05*gr.dx, 0.5, 0.12*gr.dx, 0,
                shape='full', head_width=0.05, head_length=0.025,
                lw=1, width=0.02,
                edgecolor="none", facecolor="r",
                length_includes_head=True, zorder=100)

    plt.arrow(gr.xc[1]-0.1*gr.dx, 0.5, -0.12*gr.dx, 0,
                shape='full', head_width=0.05, head_length=0.025,
                lw=1, width=0.02,
                edgecolor="none", facecolor="r",
                length_includes_head=True, zorder=100)


    gr.mark_cell_left_state(1, r"$a_{i+1/2,L}^{n+1/2}$", fontsize="large",
                            color="b")
    gr.mark_cell_right_state(0, r"$a_{i+1/2,R}^{n+1/2}$", fontsize="large",
                             color="b")

    gr.label_cell_center(0, r"$a_i$")
    gr.label_cell_center(1, r"$a_{i+1}$")


    plt.xlim(gr.xl[0]-0.125*gr.dx,gr.xr[2*ng+nzones-1]+0.125*gr.dx)

    plt.ylim(-0.25, 1.0)
    plt.axis("off")

    plt.subplots_adjust(left=0.05,right=0.95,bottom=0.05,top=0.95)

    f = plt.gcf()
    f.set_size_inches(7.0,2.0)

    plt.tight_layout()

    plt.savefig("riemann-adv.pdf")
def display_icecube_detectors(collision):

    fig = plt.figure(figsize=(7,5),dpi=100)
    ax = fig.add_subplot(1,1,1)
    ax = fig.gca(projection='3d')
    plt.subplots_adjust(top=0.98,bottom=0.02,right=0.98,left=0.02)

    q,t,x,y,z = get_detector_info(collision)
    ax.scatter(x,y,z,s=20*q)
Beispiel #26
0
def images(data, zero_to_one=True, show=True, subplots=None, caption=None):
    """
    Display images that range a grid. Especially designed for probability images, ranging from 0 to 1.

    Parameters
    ----------
    data : ndarray
        An array of images or a single image of shape. The values should range between 0 and 1 (at least, that is how they will be colorized).
    zero_to_one : bool
        If True, then 0.0 and below will be pitch black, and 1.0 and above will be chalk white.    
    show : bool
        Call `pylab.show()` inside the function.
    subplots : tuple or None
        Specify the shape of the subplots manually.
    caption : lambda(index, element)
        A function that takes the index and the element (``data[index]``) and should return a string.
    """
    import matplotlib.pylab as plt

    settings = {
        'interpolation': 'nearest',
        'cmap': plt.cm.gray,
    }

    if zero_to_one:
        settings['vmin'] = 0.0
        settings['vmax'] = 1.0

    if isinstance(data, np.ndarray) and data.ndim == 2:
        fig = plt.figure()
        plt.subplot(111).set_axis_off()
        plt.imshow(data, **settings)
    else:
        # TODO: Better find out pleasing aspect ratios
        N = len(data)
        if subplots is not None:
            sh = subplots
            assert len(data) <= np.prod(subplots) 
        elif N <= 3:
            sh = (1, len(data))
        elif N == 5 or N == 6:
            sh = (2, 3)
        elif N == 12:
            sh = (3, 4)
        else:
            perside = int(math.ceil(math.sqrt(len(data))))
            sh = (perside,)*2
        fig = plt.figure()
        for i, im in enumerate(data): 
            plt.subplot(sh[0], sh[1], 1+i).set_axis_off()
            plt.subplots_adjust(left=0.01, right=0.99, top=0.99, bottom=0.01)
            plt.imshow(im, **settings)
            if caption is not None:
                plt.title(caption(i, im))

    if show:
        plt.show()
def TwoD_Hexbin(x,  panel):
#	plt.xlim(np.min(x), np.max(x))
#	plt.ylim(np.min(y), np.max(y))
#	plt.grid(True)
#	plt.hexbin(x, y, bins='log', cmap=plt.cm.YlOrRd_r)
	plt.hist(x)
	plt.subplots_adjust(left=0.03, right=0.98, top=0.98, bottom=0.07)
	panel.canvas.draw()
	return
Beispiel #28
0
def ao_plot(o):
    a = AISReview(o)

    # fig = plt.figure()
    fig, ax = plt.subplots(2, 1, squeeze=True, figsize=(4,4), dpi=70, num=plt.gcf().number + 1)
    plt.subplots_adjust(hspace=0.3,wspace=0.0, right=0.85)

    a.density_along_orbit(ax[0], vmax=4.)
    a.modb_along_orbit(ax[1], vmax=100.)
Beispiel #29
0
    def plot_autocorrs(self, axis=0, n_rows=4, n_cols=8):
        """ Plot autocorrelations for all antennas
        """
        self.current_plot = 'multi'
        self.ax_zoomed = False
        
        bls = self.uv.d_uv_data['BASELINE']

        # Extract the relevant baselines using a truth array
        # bls = bls.tolist()
        bl_ids = set([256*i + i for i in range(1, n_rows * n_cols + 1)])
        bl_truths = np.array([(b in bl_ids) for b in bls])
        
        #print self.uv.d_uv_data['DATA'].shape
        #x_data    = self.d_uv_data['DATA'][bl_truths,0,0,:,0,axis]  # Baselines, freq and stokes
        #x_cplx    = x_data[:,:,0] + 1j * x_data[:,:,1]

        x_cplx  = self.stokes[axis][bl_truths]


        
        # Plot the figure
        #print self.uv.n_ant
        fig = self.sp_fig
        figtitle = '%s %s: %s -- %s'%(self.uv.telescope, self.uv.instrument, self.uv.source, self.uv.date_obs)
        for i in range(n_rows):
            for j in range(n_cols):
                ax = fig.add_subplot(n_rows, n_cols, i*n_cols + j +1)
                ax.set_title(self.uv.d_array_geometry['ANNAME'][i*n_cols + j], fontsize=10)
                #ax.set_title("%s %s"%(i, j))
                
                x = x_cplx[i*n_cols+j::self.uv.n_ant]
                
                if self.scale_select.currentIndex() == 0 or self.scale_select.currentIndex() == 1:
                    if x.shape[0] == self.uv.n_ant:
                        self.plot_spectrum(ax, x, label_axes=False)
                    else:
                        self.plot_spectrum(ax, x, stat='max', label_axes=False)
                        self.plot_spectrum(ax, x, stat='med', label_axes=False)
                        self.plot_spectrum(ax, x, stat='min', label_axes=False)
                else:
                    self.plot_spectrum(ax, x, label_axes=False)
                self.updateFreqAxis(ax)
                
                if i == n_rows-1:
                    ax.set_xlabel('Freq')
                if j == 0:
                    ax.set_ylabel('Amplitude')
                
                plt.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
                plt.tick_params(axis='both', which='major', labelsize=10)
                plt.tick_params(axis='both', which='minor', labelsize=8)
                plt.xticks(rotation=30)
        
        plt.subplots_adjust(left=0.05, right=0.98, top=0.95, bottom=0.1, wspace=0.3, hspace=0.45)
        return fig, ax
Beispiel #30
0
def plot_gallery(images, titles, h, w, n_row=3, n_col=4):
    """Helper function to plot a gallery of portraits"""
    pl.figure(figsize=(1.8 * n_col, 2.4 * n_row))
    pl.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)
    for i in range(n_row * n_col):
        pl.subplot(n_row, n_col, i + 1)
        pl.imshow(images[i].reshape((h, w)), cmap=pl.cm.gray)
        pl.title(titles[i], size=12)
        pl.xticks(())
        pl.yticks(())
    def plot_relative_error(self, show=True, save=False):

        ue_scaled, ve_scaled, er = self.compute_error(
            errors=["ue_scaled", "ve_scaled", "er"])

        plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]

        fig3 = pl.figure(figsize=(self.figW, self.figH))

        plot = fig3.add_subplot(1, 3, 1, aspect='equal')
        im3 = plot.imshow(ue_scaled,
                          vmin=0,
                          vmax=10,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.plot(self.Xo[:, self.dim - 1],
                  self.Xo[:, self.dim - 2],
                  'or',
                  markersize=self.marker_size)
        plot.set_title("GPR Rel. Error U",
                       size=self.text_size,
                       pad=self.title_pad)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        plot.tick_params(labelsize=self.tick_label_size)
        cbar = fig3.colorbar(im3, fraction=0.046, pad=0.04)
        cbar.ax.tick_params(labelsize=self.cbar_label_size)

        plot = fig3.add_subplot(1, 3, 2, aspect='equal')
        im3 = plot.imshow(ve_scaled,
                          vmin=0,
                          vmax=10,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.plot(self.Xo[:, self.dim - 1],
                  self.Xo[:, self.dim - 2],
                  'or',
                  markersize=self.marker_size)
        plot.set_title("GPR Rel. Error U",
                       size=self.text_size,
                       pad=self.title_pad)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        plot.tick_params(labelsize=self.tick_label_size)
        cbar = fig3.colorbar(im3, fraction=0.046, pad=0.04)
        cbar.ax.tick_params(labelsize=self.cbar_label_size)

        plot = fig3.add_subplot(1, 3, 3, aspect='equal')
        im3 = plot.imshow(er,
                          vmin=0,
                          vmax=10,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.plot(self.Xo[:, self.dim - 1],
                  self.Xo[:, self.dim - 2],
                  'or',
                  markersize=self.marker_size)
        plot.set_title("GPR Rel. Error U",
                       size=self.text_size,
                       pad=self.title_pad)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        plot.tick_params(labelsize=self.tick_label_size)
        cbar = fig3.colorbar(im3, fraction=0.046, pad=0.04)
        cbar.ax.tick_params(labelsize=self.cbar_label_size)

        pl.subplots_adjust(left=0.06,
                           bottom=0.47,
                           right=0.94,
                           top=0.88,
                           wspace=0.48,
                           hspace=0.0)

        if show:
            pl.show()

        if save:
            fig3.savefig("rel_error.png", dpi=300)
Beispiel #32
0
    ls=so.const.symbols[2],label='Narrow')

plt.plot(d_bands,2*(3.0/(s1[0]/n1[0]))**2,c=so.const.colors[3], \
    ls=so.const.symbols[0])
plt.plot(d_bands,2*(3.0/(s1[1]/n1[1]))**2,c=so.const.colors[3], \
    ls=so.const.symbols[2])

plt.axhline(2 * (3.0 / (s189 / n189))**2, c=so.const.colors[0])
plt.axhline(2 * (3.0 / (s209 / n209))**2, c=so.const.colors[3])

#plt.xlim(4,7.5)
#plt.ylim(200,4000)
plt.xlabel('Band Spacing (nm)')
plt.ylabel('N$_{exp}$')
plt.legend(loc='best')
plt.subplots_adjust(bottom=0.17, left=0.19)

plt.savefig('./plots/best_filter.png')

exposures = np.arange(100)


def plot_potassium_setup():
    plt.style.use('dark_background')
    fig, ax = plt.subplots(1, 1, sharex=True, figsize=(10, 6))

    ax.plot(so.exo.v, so.exo.s)

    #ax2 = ax.twinx() # use this for stellar contamination later
    #ax2.set_zorder(ax.get_zorder()+1) # put ax in front of ax2
    #ax2.fill_between(so.exo.v,y1=so.filt.s_alluxa_on,y2=0*so.exo.v,facecolor='m',alpha=0.5)
darkpink, lightpink =normrgb([255,20,147]), normrgb([255,182,193])
darkblue, lightblue = normrgb([0,0,128]),normrgb([135,206, 250])
for gender in genders:
    for pclass in classes:
        if gender=='male':
            colorscheme = [lightblue, darkblue]
            row=0
        else:
            colorscheme = [lightpink, darkpink]
            row=1
        group = traindf[(traindf.Sex==gender)&(traindf.Pclass==pclass)]
        group = group.groupby(['Embarked', 'Survived']).size().unstack()
        group = group.div(group.sum(1), axis=0)
        group.plot(kind='barh', ax=axes2[row, (int(pclass)-1)], color=colorscheme, stacked=True, legend=False).set_title('Class '+str(pclass)).axes.get_xaxis().set_ticks([])

plt.subplots_adjust(wspace=0.4, hspace=1.3)

fhandles, flabels = axes2[1,2].get_legend_handles_labels()
mhandles, mlabels = axes2[0,2].get_legend_handles_labels()
plt.figlegend(fhandles, ('die', 'live'), title='Female', loc='center', bbox_to_anchor=(0.06, 0.45, 1.1, .102))
plt.figlegend(mhandles, ('die', 'live'), 'center', title='Male',bbox_to_anchor=(-0.15, 0.45, 1.1, .102))

fig2.show()

def removeBadStringFromString(string, badStringList):
    for badString in badStringList:
        string = string.replace(badString, '')
    return string

def removeBadStringFromLabels(ax, badStringList):
    labels = [item.get_text() for item in ax.get_yticklabels()]
Beispiel #34
0
#plt.ylim(-4E+05,4E+05)
vel_obs.legend()

#------------------------------------save figure---------------------------
plt.savefig('TNG Filtered 0.3Hz-250s', format='png', dpi=1200)

#####################################figure 4######################################
plt.figure(4)
fig4 = plt.figure(4)
fig4.suptitle("JCJI", fontsize=14)

plt.rc('xtick', labelsize=6)
plt.rc('ytick', labelsize=6)
plt.rc('legend', fontsize=8)

plt.subplots_adjust(top=0.8)

#------------------------------graph 1---------------------------------
vel_obs = fig4.add_subplot(111, label="1")
vel_ = fig4.add_subplot(111, label="2", frame_on=False)

tr_obs = obs[0]
obs_filt = tr_obs.copy()
obs_filt.filter('lowpass', freq=0.3, corners=2, zerophase=True)
t_obs = np.arange(0, obs[0].stats.npts / obs[0].stats.sampling_rate,
                  obs[0].stats.delta)

vel_obs.plot(t_obs, obs_filt.data, label='Seismogram observasi', linewidth=0.5)
vel_obs.set_ylabel('Kecepatan (counts)', fontsize=7)
vel_obs.set_xlabel('Waktu (s)', fontsize=8)
vel_obs.tick_params(axis='x', colors='b')
Beispiel #35
0
def pair_plot(df,
              var_list,
              var_lims,
              var_labels,
              num_inputs=4,
              vmax=4,
              bins=30,
              alpha=0.7,
              colors=None,
              marker='.',
              ms=20,
              clabels=True,
              opt='hexbin',
              fig=None,
              ax=None,
              figsize=[16, 12]):

    if fig == None:
        Nx = len(var_list)
        Ny = len(var_list)
        fig, ax = plt.subplots(
            Nx,
            Ny,
            gridspec_kw={
                'width_ratios':
                [2 * figsize[0] / figsize[1] for i in range(Ny - 1)] + [1],
                'height_ratios': [1] + [2 for i in range(Nx - 1)],
            },
            figsize=figsize)

    for i, var_name in enumerate(var_list):
        for j, var_name2 in enumerate(var_list):
            if (j < i):

                y = df[var_name].values
                x = df[var_name2].values
                if i >= num_inputs:
                    if opt == 'hexbin':
                        hexbin = ax[i, j].hexbin(x,
                                                 y,
                                                 gridsize=bins,
                                                 cmap=Reds,
                                                 mincnt=0,
                                                 extent=var_lims[var_name2] +
                                                 var_lims[var_name])
                        ax[i, j].hexbin(x,
                                        y,
                                        gridsize=bins,
                                        bins='log',
                                        cmap=Reds,
                                        vmin=0,
                                        vmax=vmax,
                                        alpha=alpha,
                                        edgecolors='none',
                                        mincnt=0,
                                        extent=var_lims[var_name2] +
                                        var_lims[var_name])
                        density_contour(hexbin,
                                        ax=ax[i, j],
                                        alpha=1.,
                                        colors='grey',
                                        c='k',
                                        clabels=clabels)
                    elif opt == 'scatter':
                        if colors == None:
                            ax[i,
                               j].scatter(x,
                                          y,
                                          alpha=alpha,
                                          marker=marker,
                                          s=ms,
                                          color=sns.color_palette('Reds_d')[1],
                                          zorder=10000)
                        else:
                            ax[i, j].scatter(x,
                                             y,
                                             alpha=alpha,
                                             marker=marker,
                                             s=ms,
                                             color=colors,
                                             zorder=10000)
                else:
                    if opt == 'hexbin':
                        hexbin = ax[i, j].hexbin(x,
                                                 y,
                                                 gridsize=bins,
                                                 cmap=Blues,
                                                 mincnt=0,
                                                 extent=var_lims[var_name2] +
                                                 var_lims[var_name])
                        ax[i, j].hexbin(x,
                                        y,
                                        gridsize=bins,
                                        bins='log',
                                        cmap=Blues,
                                        vmin=0,
                                        vmax=vmax,
                                        alpha=alpha,
                                        edgecolors='none',
                                        mincnt=0,
                                        extent=var_lims[var_name2] +
                                        var_lims[var_name])
                        density_contour(hexbin,
                                        ax=ax[i, j],
                                        alpha=1,
                                        colors='grey',
                                        c='k',
                                        clabels=clabels)
                    elif opt == 'scatter':
                        if colors == None:
                            ax[i, j].scatter(
                                x,
                                y,
                                alpha=alpha,
                                marker=marker,
                                s=ms,
                                color=sns.color_palette("Blues_d")[1],
                                zorder=10000)
                        else:
                            ax[i, j].scatter(x,
                                             y,
                                             alpha=alpha,
                                             marker=marker,
                                             s=ms,
                                             color=colors,
                                             zorder=10000)
                ax[i, j].set_ylim(var_lims[var_name])
                ax[i, j].set_xlim(var_lims[var_name2])

            elif (i == 0) & (j < len(var_list) - 1):
                y = df[var_name2].values
                if colors == None:
                    if i >= num_inputs:
                        ax[i, j].hist(y,
                                      bins=bins,
                                      normed=True,
                                      range=var_lims[var_name2],
                                      lw=0,
                                      color=sns.color_palette('Reds_d')[1])
                    else:
                        ax[i, j].hist(y,
                                      bins=bins,
                                      normed=True,
                                      range=var_lims[var_name2],
                                      lw=0,
                                      color=sns.color_palette('Blues_d')[1])
                else:
                    ax[i, j].hist(y,
                                  bins=bins,
                                  normed=True,
                                  range=var_lims[var_name2],
                                  lw=1,
                                  color='k',
                                  histtype=u'step')
                ax[i, j].set_xlim(var_lims[var_name2])
                ax[i, j].set_yticklabels([])
            elif (j == len(var_list) - 1) & (i > 0):
                x = df[var_name].values
                if colors == None:
                    if i >= num_inputs:
                        ax[i, j].hist(x,
                                      bins=bins,
                                      normed=True,
                                      range=var_lims[var_name],
                                      lw=0,
                                      color=sns.color_palette('Reds_d')[1],
                                      orientation=u'horizontal')
                    else:
                        ax[i, j].hist(x,
                                      bins=bins,
                                      normed=True,
                                      range=var_lims[var_name],
                                      lw=0,
                                      color=sns.color_palette('Blues_d')[1],
                                      orientation=u'horizontal')
                else:
                    ax[i, j].hist(x,
                                  bins=bins,
                                  normed=True,
                                  range=var_lims[var_name],
                                  lw=1,
                                  color='k',
                                  histtype=u'step',
                                  orientation=u'horizontal')
                ax[i, j].set_ylim(var_lims[var_name])
                ax[i, j].set_xticklabels([])
            else:
                ax[i, j].set_visible(False)
            if i != 0:
                ax[j, i].set_yticklabels([])
            if i == 0:
                if j > 0:
                    ax[j, i].set_ylabel(var_labels[var_name2])
                else:
                    ax[j, i].set_ylabel('PDF')

            if i != len(var_list) - 1:
                ax[i, j].set_xticklabels([])
            if i == len(var_list) - 1:
                if j < len(var_list) - 1:
                    ax[i, j].set_xlabel(var_labels[var_name2])
                else:
                    ax[i, j].set_xlabel('PDF')
                #xticks = ax[i,j].xaxis.get_major_ticks()
                #xticks[-1].label1.set_visible(False)
                #if len(xticks)>8:
                #    for itick in range(1,len(xticks)-1,2):
                #        xticks[itick].label1.set_visible(False)

    plt.subplots_adjust(
        left=.1,  # the left side of the subplots of the figure
        right=.99,  # the right side of the subplots of the figure
        bottom=.10,  # the bottom of the subplots of the figure
        top=.99,  # the top of the subplots of the figure
        wspace=
        0.1,  # the amount of width reserved for blank space between subplots
        hspace=0.1
    )  # the amount of height reserved for white space between subplots
    return fig, ax
def NR_plot(stream, NR_stream, detections, false_detections=False,\
            size=(18.5,10), save=False, title=False):
    """
    Function to plot the Network response alongside the streams used - highlights
    detection times in the network response

    :type stream: :class: obspy.Stream
    :param stream: Stream to plot
    :type NR_stream: :class: obspy.Stream
    :param NR_stream: Stream for the network response
    :type detections: List of datetime objects
    :param detections: List of the detections
    :type false_detections: List of datetime
    :param false_detections: Either False (default) or list of false detection\
     times
    :type size: tuple
    :param size: Size of figure, default is (18.5,10)
    :type save: bool
    :param save: Save figure or plot to screen, if not False, must be string of\
        save path
    :type title: str
    :param title: String for the title of the plot, set to False
    """
    import datetime as dt
    import matplotlib.dates as mdates
    fig, axes = plt.subplots(len(stream) + 1, 1, sharex=True, figsize=size)
    if len(stream) > 1:
        axes = axes.ravel()
    else:
        return
    mintime = stream.sort(['starttime'])[0].stats.starttime
    stream.sort(['network', 'station', 'starttime'])
    for i, tr in enumerate(stream):
        delay = tr.stats.starttime - mintime
        delay *= tr.stats.sampling_rate
        y = tr.data
        x=[tr.stats.starttime + dt.timedelta(seconds=s/tr.stats.sampling_rate)\
           for s in xrange(len(y))]
        x = mdates.date2num(x)
        axes[i].plot(x, y, 'k', linewidth=1.1)
        axes[i].set_ylabel(tr.stats.station + '.' + tr.stats.channel,
                           rotation=0)
        axes[i].yaxis.set_ticks([])
        axes[i].set_xlim(x[0], x[-1])
    # Plot the network response
    tr = NR_stream[0]
    delay = tr.stats.starttime - mintime
    delay *= tr.stats.sampling_rate
    y = tr.data
    x=[tr.stats.starttime + dt.timedelta(seconds=s/tr.stats.sampling_rate)\
        for s in range(len(y))]
    x = mdates.date2num(x)
    axes[i].plot(x, y, 'k', linewidth=1.1)
    axes[i].set_ylabel(tr.stats.station + '.' + tr.stats.channel, rotation=0)
    axes[i].yaxis.set_ticks([])
    axes[-1].set_xlabel('Time')
    axes[-1].set_xlim(x[0], x[-1])
    # Plot the detections!
    ymin, ymax = axes[-1].get_ylim()
    if false_detections:
        for detection in false_detections:
            xd = mdates.date2num(detection)
            axes[-1].plot((xd, xd), (ymin, ymax),
                          'k--',
                          linewidth=0.5,
                          alpha=0.5)
    for detection in detections:
        xd = mdates.date2num(detection)
        axes[-1].plot((xd, xd), (ymin, ymax), 'r--', linewidth=0.75)
    # Set formatters for x-labels
    mins = mdates.MinuteLocator()
    if (tr.stats.endtime.datetime-tr.stats.starttime.datetime).total_seconds() >= 10800\
       and (tr.stats.endtime.datetime-tr.stats.starttime.datetime).total_seconds() <= 25200:
        hours = mdates.MinuteLocator(byminute=[0, 15, 30, 45])
    elif (tr.stats.endtime.datetime -
          tr.stats.starttime.datetime).total_seconds() <= 1200:
        hours = mdates.MinuteLocator(byminute=range(0, 60, 2))
    elif (tr.stats.endtime.datetime-tr.stats.starttime.datetime).total_seconds() > 25200\
        and (tr.stats.endtime.datetime-tr.stats.starttime.datetime).total_seconds() <= 172800:
        hours = mdates.HourLocator(byhour=range(0, 24, 3))
    elif (tr.stats.endtime.datetime -
          tr.stats.starttime.datetime).total_seconds() > 172800:
        hours = mdates.DayLocator()
    else:
        hours = mdates.MinuteLocator(byminute=range(0, 60, 5))
    hrFMT = mdates.DateFormatter('%Y/%m/%d %H:%M:%S')
    axes[-1].xaxis.set_major_locator(hours)
    axes[-1].xaxis.set_major_formatter(hrFMT)
    axes[-1].xaxis.set_minor_locator(mins)
    plt.gcf().autofmt_xdate()
    axes[-1].fmt_xdata = mdates.DateFormatter('%Y/%m/%d %H:%M:%S')
    plt.subplots_adjust(hspace=0)
    if title:
        axes[0].set_title(title)
    if not save:
        plt.show()
        plt.close()
    else:
        plt.savefig(save)
    return
Beispiel #37
0
    def plotreport(self, lc_data, ext_image=None, save=False):
        time = lc_data[:, 0]
        flux = lc_data[:, 1]
        xpos = lc_data[:, 2]
        ypos = lc_data[:, 3]
        pixa = lc_data[:, 4]
        msky = lc_data[:, 5]

        #searching NaN value in flux
        nani = np.where(np.isnan(lc_data[:, 1]) == 1)
        # transferring list to array
        nan_array = np.asarray(nani[0])

        #remove NaN elements from data
        vali = np.where(np.isnan(lc_data[:, 1]) == 0)

        flux_sans_NaN = lc_data[vali, 1]
        m_flux = np.median(flux_sans_NaN)
        std_flux = np.std(flux_sans_NaN)

        # check total number of pixels in aperture less than 3-sigam of median value
        tnp_index = np.where(pixa < np.median(pixa) - np.std(pixa) * 3.0)

        plt.clf()
        plt.figure(1, figsize=(8, 11))
        plt.subplots_adjust(hspace=0.2)

        win2 = plt.subplot(411)
        win2.plot(time, flux, 'k-', drawstyle='steps-mid')
        win2.plot(time[tnp_index],
                  time[tnp_index] * 0.0 + (m_flux + 3.0 * std_flux), 'rv')
        if nan_array.size > 0:
            for index in range(nan_array.size):
                win2.axvline(x=time[nan_array[index]], color='r', ls='--')
        win2.axhline(y=(m_flux - 3.0 * std_flux), color='r', ls='-.')
        win2.axhline(y=(m_flux + 3.0 * std_flux), color='r', ls='-.')
        win2.set_xlim(0, time[-1])
        win2.set_ylim(0, m_flux + 5.0 * std_flux)
        win2.set_ylabel('Intensity (count)')
        win2.set_title('Light Curves: ' + op.basename(self.filename) + ' [f' +
                       str(self.fibre) + ']')

        win1 = plt.subplot(412, sharex=win2)
        win1.plot(time, xpos, 'g.', label='x')
        win1.plot(time, ypos, 'b.', label='y')
        #an = np.linspace(0,2*np.pi,359)
        #win1.imshow(ext_image[0], cmap=plt.cm.gray, vmin=10, vmax=1000)
        #win1.plot(5*np.sin(an)+xpos[0], 5*np.cos(an)+ypos[0], 'r-')
        #win1.plot(10*np.sin(an)+xpos[0], 10*np.cos(an)+ypos[0], 'r--')
        win1.set_xlim(0, time[-1])
        win1.set_ylim(0, 40)
        win1.set_ylabel('Position')
        win1.legend()

        win3 = plt.subplot(413, sharex=win2)
        win3.plot(time, pixa, 'k-', drawstyle='steps-mid')
        espected_pixa = np.pi * self.aperture**2
        win3.axhline(y=espected_pixa, color='r', ls='--')
        if nan_array.size > 0:
            for index in range(nan_array.size):
                win3.axvline(x=time[nan_array[index]], color='r', ls='--')
        win3.set_xlim(0, time[-1])
        win3.set_ylim(
            np.mean(pixa) - 6.0 * np.std(pixa),
            np.mean(pixa) + 6.0 * np.std(pixa))
        win3.set_ylabel('Pixel')
        win3.set_title('Total pixels in aperture (%2d)' % (self.aperture))

        win4 = plt.subplot(414, sharex=win2)
        if nan_array.size > 0:
            for index in range(nan_array.size):
                win4.axvline(x=time[nan_array[index]], color='r', ls='--')
        win4.plot(time, msky, 'k-', drawstyle='steps-mid')
        win4.set_xlim(0, time[-1])
        win4.set_xlabel('Time (sec)')
        win4.set_ylabel('Sky value (count/pixel)')
        win4.set_title('Median sky value')

        xticklabels = win1.get_xticklabels() + win2.get_xticklabels(
        ) + win3.get_xticklabels()
        plt.setp(xticklabels, visible=False)

        plt.show()

        if save == 1:
            save_filename = 'f' + str(self.fibre) + '_' + op.basename(
                self.filename)[:-4] + 'png'
            plt.savefig(save_filename, format='png')
Beispiel #38
0
plt.subplot(2, 3, 2)
plt.errorbar(data2[7:14, 0], data2[7:14, 1], marker=".")
plt.title("l1 = 2, l2 = 3")
plt.xlabel("N")
plt.ylabel("<r2>")
plt.grid()

plt.subplot(2, 3, 3)
plt.errorbar(data2[14:21, 0], data2[14:21, 1], marker=".")
plt.title("l1 = 3, l2 = 4")
plt.xlabel("N")
plt.ylabel("<r2>")
plt.grid()

plt.subplot(2, 3, 4)
plt.errorbar(data2[21:28, 0], data2[21:28, 1], marker=".")
plt.title("l1 = 4, l2 = 5")
plt.xlabel("N")
plt.ylabel("<r2>")
plt.grid()

plt.subplot(2, 3, 5)
plt.errorbar(data2[28:, 0], data2[28:, 1], marker=".")
plt.title("l1 = 5, l2 = 6")
plt.xlabel("N")
plt.ylabel("<r2>")
plt.grid()

plt.subplots_adjust(hspace=.3)
plt.savefig("plots2.png")
Beispiel #39
0
def plot_by_subs(data,
                 output_name,
                 colors,
                 shapes,
                 sub_ids,
                 loc_ids,
                 roi_name,
                 figsize=(15, 5)):
    """
    Plot_by_subs takes a data rec_array and loops through three measures:
        fa, md, and vol_vox and plots each on separate plots with the
        x-axis representing the individual subjects
    
    Required:   data rec_array (eg: data)
                output_name (eg: results_dir/'plot_by_subs.png')
                colors (eg: colors)
                shapes (eg: shapes)
                sub_ids (eg: sub_ids)
                loc_ids (eg: loc_ids)

    Optional:   figsize (default 15 x 5)

    Example usage:
        plot_by_subs(data=data, output_name=results_dir/'plot_by_subs.png',
                        colors=colors, shapes=shapes, sub_ids=sub_ids,
                        loc_ids=loc_ids, figsize=(15,5))

    """
    #==========================================================================
    import numpy as np
    import matplotlib.pylab as plt
    from matplotlib.ticker import MaxNLocator
    #==========================================================================

    fig = plt.figure(figsize=figsize)
    ax1 = plt.subplot(131)
    ax2 = plt.subplot(132)
    ax3 = plt.subplot(133)
    ax = [ax1, ax2, ax3]

    # Loop through the three measures (FA, MD, VOL_VOX)
    for count, measure in enumerate(['fa', 'md', 'vol_vox']):

        # Now loop through the subjects and the locations
        for i, sub in enumerate(sub_ids):

            for j, loc in enumerate(loc_ids):

                # Assign the correct color and shape for the marker
                c = colors[j, i]
                m = shapes[j]

                # Mask the data so you only have this sub at this loc's numbers
                mask = (data['sub'] == sub) & (data['loc_id'] == loc)

                # Find the number of data points you have for this sub at this location
                n = np.sum(mask)

                if n > 1:
                    # If you have more than one data point then we're going to plot
                    # the individual points (kinda small and a little transparent)
                    ax[count].scatter(np.ones(n) * sub,
                                      data[measure][mask],
                                      c=c,
                                      edgecolor=c,
                                      marker=m,
                                      s=20,
                                      alpha=0.5)

                    # ... connect them with a line ...
                    ax[count].plot(np.ones(n) * sub, data[measure][mask], c=c)

                # And for everyone we'll plot the average
                # (which is just the data if you only have one point)
                mean = np.average(data[measure][mask])
                ax[count].scatter(sub, mean, c=c, edgecolor=c, marker=m, s=50)

                # Set the y limits
                # This is to deal with very small numbers (the MaxNLocator gets all turned around!)
                buffer = (np.max(data[measure]) - np.min(data[measure])) / 10
                upper = np.max(data[measure]) + buffer
                lower = np.min(data[measure]) - buffer
                ax[count].set_ybound(upper, lower)

        # Set the axis labels
        ax[count].set_ylabel('{}'.format(measure.upper()))
        ax[count].set_xlabel('Subject ID')

    # Adjust the power limits so that you use scientific notation on the y axis
    plt.ticklabel_format(style='sci', axis='y')
    [a.yaxis.major.formatter.set_powerlimits((-3, 3)) for a in ax]

    # Adjust the y axis ticks so that there are 6 at sensible places
    [a.yaxis.set_major_locator(MaxNLocator(6)) for a in ax]

    # Set the xaxis ticks to be sensible
    [a.xaxis.set_major_locator(MaxNLocator(4)) for a in ax]

    # Set the x axis ticks to be at the sub_ids
    [a.set_xticks(sub_ids) for a in ax]

    # Set the overall title
    fig.suptitle('Region of interest: {}'.format(roi_name), fontsize=20)
    plt.subplots_adjust(top=0.85)

    # And now save it
    plt.savefig(output_name,
                bbox_inches=0,
                facecolor='w',
                edgecolor='w',
                transparent=True)
Beispiel #40
0
def pair_plot_last_row(df,
                       var_list,
                       var_lims,
                       var_labels,
                       num_inputs=4,
                       vmax=4,
                       bins=30,
                       alpha=0.7,
                       colors=None,
                       marker='.',
                       ms=20,
                       clabels=True,
                       opt='hexbin',
                       fig=None,
                       ax=None,
                       figsize=[12, 3],
                       xlabels=True):

    if fig == None:
        fig, ax = plt.subplots(1,
                               len(var_list),
                               gridspec_kw={
                                   'width_ratios':
                                   [2 for i in range(len(var_list) - 1)] + [1]
                               },
                               figsize=figsize)

    i = 0
    var_name = var_list[-1]
    for j, var_name2 in enumerate(var_list):
        if (j < len(var_list) - 1):
            y = df[var_name].values
            x = df[var_name2].values

            if opt == 'hexbin':
                hexbin = ax[j].hexbin(x,
                                      y,
                                      gridsize=bins,
                                      cmap=Reds,
                                      mincnt=0,
                                      extent=var_lims[var_name2] +
                                      var_lims[var_name])
                ax[j].hexbin(x,
                             y,
                             gridsize=bins,
                             bins='log',
                             cmap=Reds,
                             vmin=0,
                             vmax=vmax,
                             alpha=alpha,
                             edgecolors='none',
                             mincnt=0,
                             extent=var_lims[var_name2] + var_lims[var_name])
                density_contour(hexbin,
                                ax=ax[j],
                                alpha=1.,
                                colors='grey',
                                c='k',
                                clabels=clabels)
            elif opt == 'scatter':
                if colors == None:
                    ax[j].scatter(x,
                                  y,
                                  alpha=alpha,
                                  marker=marker,
                                  s=ms,
                                  color=sns.color_palette('Reds_d')[1],
                                  zorder=10000)
                else:
                    ax[j].scatter(x,
                                  y,
                                  alpha=alpha,
                                  marker=marker,
                                  s=ms,
                                  color=colors,
                                  zorder=10000)
            ax[j].set_ylim(var_lims[var_name])
            ax[j].set_xlim(var_lims[var_name2])

        else:
            x = df[var_name].values
            if colors == None:
                ax[j].hist(x,
                           bins=bins,
                           normed=True,
                           range=var_lims[var_name],
                           lw=0,
                           color=sns.color_palette('Reds_d')[1],
                           orientation=u'horizontal')
            else:
                ax[j].hist(x,
                           bins=bins,
                           normed=True,
                           range=var_lims[var_name],
                           lw=1,
                           color='k',
                           histtype=u'step',
                           orientation=u'horizontal')
            ax[j].set_ylim(var_lims[var_name])
            ax[j].set_yticklabels([])

        if j != 0:
            ax[j].set_yticklabels([])
        else:
            ax[j].set_ylabel(var_labels[var_name])
        if xlabels:
            if j < len(var_list) - 1:
                ax[j].set_xlabel(var_labels[var_name2])
                xticks = ax[0].xaxis.get_major_ticks()
                xticks[0].label1.set_visible(False)
            else:
                ax[j].set_xticklabels([])
                ax[j].set_xlabel('PDF')
        else:
            ax[j].set_xticklabels([])

    plt.subplots_adjust(
        left=.07,  # the left side of the subplots of the figure
        right=.99,  # the right side of the subplots of the figure
        bottom=.25,  # the bottom of the subplots of the figure
        top=.95,  # the top of the subplots of the figure
        wspace=
        0.1,  # the amount of width reserved for blank space between subplots
        hspace=0.1
    )  # the amount of height reserved for white space between subplots
    return fig, ax
    print(filename)


image_name = "D:/IDC_regular_ps50_idx5/9135/1/9135_idx5_x1701_y1851_class1.png" #Image to be used as query
def plotImage(image_location):
    image = cv2.imread(image_name)
    image = cv2.resize(image, (50,50))
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)); plt.axis('off')
    return
plotImage(image_name)

# Plot Multiple Images
bunchOfImages = imagePatches
i_ = 0
plt.rcParams['figure.figsize'] = (10.0, 10.0)
plt.subplots_adjust(wspace=0, hspace=0)
for l in bunchOfImages[:25]:
    im = cv2.imread(l)
    im = cv2.resize(im, (50, 50)) 
    plt.subplot(5, 5, i_+1) #.set_title(l)
    plt.imshow(cv2.cvtColor(im, cv2.COLOR_BGR2RGB)); plt.axis('off')
    i_ += 1

def randomImages(a):
    r = random.sample(a, 4)
    plt.figure(figsize=(16,16))
    plt.subplot(131)
    plt.imshow(cv2.imread(r[0]))
    plt.subplot(132)
    plt.imshow(cv2.imread(r[1]))
    plt.subplot(133)
Beispiel #42
0
#		# Apply the newly found best focus value:
#		if float(optimum_focus) > 1.5 and float(optimum_focus) < 3.5:
#			try:
#				print set_tsi.set_position_instrumental_hexapod_z_offset(param=float(optimum_focus))
#			except Exception,e:
#				print e
#				print "Could not preset focus value of hexapod"
#		else:
#			print "The focus found was not within accepted values..."
#	except Exception,e:
#		print e

    plt.figure(figsize=(10.0, 8.0), dpi=40, facecolor='w', edgecolor='k')
    plt.subplots_adjust(left=0.15,
                        bottom=0.20,
                        right=0.95,
                        top=0.90,
                        wspace=0.4,
                        hspace=0.3)

    plt.plot(numpy.array(focus_arr), numpy.array(fwhm_arr), 'r*')

    plt.plot(numpy.array(new_focus_arr), numpy.array(new_fwhm_arr), 'b*')

    plt.xlim([min(focus_arr) - 0.1, max(focus_arr) + 0.1])
    plt.ylim(
        [min(numpy.array(fwhm_arr)) - 1.0,
         max(numpy.array(fwhm_arr)) + 1.0])

    plt.ylabel("FWHM [arcseconds]")
    plt.xlabel("Focus [mm]")
Beispiel #43
0
import matplotlib.pylab as plt
plt.rcParams['ytick.major.pad'] = '12'
from numpy import linspace

plt.ion()

bias = 6.
layers = 24
layer_list = linspace(-(layers - 1.) / 2., (layers - 1.) / 2., layers)

v = linspace(-bias / 2, bias / 2, layers)
fig = plt.figure()
plt.plot(layer_list, v, 'b-o', label="V")
leg = plt.legend(loc="best", prop={'size': 30})
leg.draw_frame(False)
plt.xlim(-12, 12)
plt.xlabel("n", fontsize=30)
plt.ylabel("V(n)", fontsize=30)
plt.xticks(fontsize=30)
plt.yticks(fontsize=30)
plt.subplots_adjust(left=0.2, right=0.975, top=0.95, bottom=0.2)
fig.set_size_inches(10, 7)

plt.savefig("test.pdf")

raw_input()
    def plot_kukv(self, show=True, save=False):

        plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]

        raw_ku = self.ku
        raw_kv = self.kv

        ku = np.sqrt(self.ku)
        kv = np.sqrt(self.kv)

        fig3 = pl.figure(figsize=(self.figW, self.figH))

        plot = fig3.add_subplot(1, 3, 1, aspect='equal')
        im5 = plot.imshow(ku,
                          vmin=0,
                          vmax=0.5,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.plot(self.Xo[:, self.dim - 1],
                  self.Xo[:, self.dim - 2],
                  'or',
                  markersize=self.marker_size)
        plot.set_title("GPR Ku (Standard Deviation)", size=self.text_size)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        fig3.colorbar(im5, fraction=0.046, pad=0.04)

        plot = fig3.add_subplot(1, 3, 2, aspect='equal')
        im6 = plot.imshow(kv,
                          vmin=0,
                          vmax=0.5,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.plot(self.Xo[:, self.dim - 1],
                  self.Xo[:, self.dim - 2],
                  'or',
                  markersize=self.marker_size)
        plot.set_title("GPR Ku (Standard Deviation)", size=self.text_size)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        fig3.colorbar(im6, fraction=0.046, pad=0.04)

        plot = fig3.add_subplot(1, 3, 3, aspect='equal')
        im7 = plot.imshow(np.sqrt(
            np.divide(np.add(np.power(raw_ku, 2), np.power(raw_kv, 2)), 2)),
                          vmin=0,
                          vmax=0.5,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.plot(self.Xo[:, self.dim - 1],
                  self.Xo[:, self.dim - 2],
                  'or',
                  markersize=self.marker_size)
        plot.set_title("GPR Ku (Standard Deviation)", size=self.text_size)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        fig3.colorbar(im7, fraction=0.046, pad=0.04)

        pl.subplots_adjust(left=0.05,
                           bottom=0.47,
                           right=0.95,
                           top=0.88,
                           wspace=0.35,
                           hspace=0.0)

        if show:
            pl.show()

        if save:
            fig3.savefig("kukv.png", dpi=300)
def multi_event_singlechan(streams, picks, clip=10.0, pre_pick=2.0,\
                           freqmin=False, freqmax=False, realign=False, \
                           cut=(-3.0,5.0), PWS=False, title=False):
    """
    Function to plot data from a single channel at a single station for multiple
    events - data will be alligned by their pick-time given in the picks

    :type streams: List of :class:obspy.stream
    :param streams: List of the streams to use, can contain more traces than\
        you plan on plotting
    :type picks: List of :class:PICK
    :param picks: List of picks, one for each stream
    :type clip: float
    :param clip: Length in seconds to plot, defaults to 10.0
    :type pre_pick: Float
    :param pre_pick: Length in seconds to extract and plot before the pick,\
        defaults to 2.0
    :type freqmin: float
    :param freqmin: Low cut for bandpass in Hz
    :type freqmax: float
    :param freqmax: High cut for bandpass in Hz
    :type realign: Bool
    :param realign: To compute best alignement based on correlation or not.
    :type cut: tuple:
    :param cut: tuple of start and end times for cut in seconds from the pick
    :type PWS: bool
    :param PWS: compute Phase Weighted Stack, if False, will compute linear stack
    :type title: str
    :param title: Plot title.

    :returns: Alligned and cut traces, and new picks
    """
    from eqcorrscan.utils import stacking
    import copy
    from eqcorrscan.core.match_filter import normxcorr2
    from obspy import Stream
    fig, axes = plt.subplots(len(picks) + 1, 1, sharex=True, figsize=(7, 12))
    axes = axes.ravel()
    traces = []
    al_traces = []
    # Keep input safe
    plist = copy.deepcopy(picks)
    st_list = copy.deepcopy(streams)
    for i, pick in enumerate(plist):
        if st_list[i].select(station=pick.station, \
            channel='*'+pick.channel[-1]):
            tr=st_list[i].select(station=pick.station, \
                channel='*'+pick.channel[-1])[0]
        else:
            print 'No data for ' + pick.station + '.' + pick.channel
            continue
        tr.detrend('linear')
        if freqmin:
            tr.filter('bandpass', freqmin=freqmin, freqmax=freqmax)
        if realign:
            tr_cut = tr.copy()
            tr_cut.trim(pick.time+cut[0], pick.time+cut[1],\
                        nearest_sample=False)
            if len(tr_cut.data) <= 0.5 * (cut[1] -
                                          cut[0]) * tr_cut.stats.sampling_rate:
                print 'Not enough in the trace for ' + pick.station + '.' + pick.channel
                print 'Suggest removing pick from sfile at time ' + str(
                    pick.time)
            else:
                al_traces.append(tr_cut)
        else:
            tr.trim(pick.time-pre_pick, pick.time+clip-pre_pick,\
                    nearest_sample=False)
        if len(tr.data) == 0:
            print 'No data in the trace for ' + pick.station + '.' + pick.channel
            print 'Suggest removing pick from sfile at time ' + str(pick.time)
            continue
        traces.append(tr)
    if realign:
        shift_len = int(0.25 * (cut[1] - cut[0]) *
                        al_traces[0].stats.sampling_rate)
        shifts = stacking.align_traces(al_traces, shift_len)
        for i in xrange(len(shifts)):
            print 'Shifting by ' + str(shifts[i]) + ' seconds'
            pick.time -= shifts[i]
            traces[i].trim(pick.time - pre_pick, pick.time + clip-pre_pick,\
                           nearest_sample=False)
    # We now have a list of traces
    traces = [(trace, trace.stats.starttime.datetime) for trace in traces]
    traces.sort(key=lambda tup: tup[1])
    traces = [trace[0] for trace in traces]
    # Plot the traces
    for i, tr in enumerate(traces):
        y = tr.data
        x = np.arange(len(y))
        x = x / tr.stats.sampling_rate  # convert to seconds
        axes[i + 1].plot(x, y, 'k', linewidth=1.1)
        # axes[i+1].set_ylabel(tr.stats.starttime.datetime.strftime('%Y/%m/%d %H:%M'),\
        # rotation=0)
        axes[i + 1].yaxis.set_ticks([])
    traces = [Stream(trace) for trace in traces]
    if PWS:
        linstack = stacking.PWS_stack(traces)
    else:
        linstack = stacking.linstack(traces)
    tr=linstack.select(station=picks[0].station, \
            channel='*'+picks[0].channel[-1])[0]
    y = tr.data
    x = np.arange(len(y))
    x = x / tr.stats.sampling_rate
    axes[0].plot(x, y, 'r', linewidth=2.0)
    axes[0].set_ylabel('Stack', rotation=0)
    axes[0].yaxis.set_ticks([])
    for i, slave in enumerate(traces):
        cc = normxcorr2(tr.data, slave[0].data)
        axes[i + 1].set_ylabel('cc=' + str(round(np.max(cc), 2)), rotation=0)
        axes[i+1].text(0.9, 0.15, str(round(np.max(slave[0].data))), \
                       bbox=dict(facecolor='white', alpha=0.95),\
                       transform=axes[i+1].transAxes)
        axes[i+1].text(0.7, 0.85, slave[0].stats.starttime.datetime.strftime('%Y/%m/%d %H:%M:%S'), \
                       bbox=dict(facecolor='white', alpha=0.95),\
                       transform=axes[i+1].transAxes)
    axes[-1].set_xlabel('Time (s)')
    if title:
        axes[0].set_title(title)
    plt.subplots_adjust(hspace=0)
    plt.show()
    return traces, plist
def visualize_clusters(seqs, true_systems, true_cluster_ids, transform_fns,
                       plot_filepath):
    """Visualizes learned params with colors of ground truth clusters.

  Only plots the first two dimensions of learned params.

  Args:
    seqs: A list of numpy arrays.
    true_systems: A list of LinearDynamicalSystem objects.
    true_cluster_ids: A numpy array of ground truth cluster ids.
    transform_fns: The transfrom fns for clustering.
    filepath: Path to save the plot.
  """
    num_subplots = len(transform_fns)
    subplot_id = 1
    subplot_cols = (num_subplots + 1) / 2
    pylab.figure(figsize=(4 * 2, 4 * subplot_cols))
    if true_systems is not None:
        num_subplots += 1
        subplot_cols = (num_subplots + 1) / 2
        pylab.figure(figsize=(4 * 2, 4 * subplot_cols))
        pylab.subplot(subplot_cols, 2, subplot_id)
        subplot_id += 1
        ax = sns.scatterplot(x=[a.get_spectrum()[0] for a in true_systems],
                             y=[a.get_spectrum()[1] for a in true_systems],
                             palette=sns.color_palette(
                                 'Set2',
                                 np.max(true_cluster_ids) + 1),
                             hue=true_cluster_ids)
        ax.set(xlabel='true eig value 1', ylabel='true eig value 2')
        ax.set_title('Ground Truth')

    plot_data_collection = None
    for i, k in enumerate(transform_fns.keys()):
        pylab.subplot(subplot_cols, 2, subplot_id)
        subplot_id += 1
        learned_params = [transform_fns[k](s) for s in seqs]

        # pylint: disable=g-complex-comprehension
        plot_data = {str(i): [p[i] for p in learned_params] for i \
            in xrange(len(learned_params[0]))}
        plot_data['method'] = [k] * len(learned_params)
        plot_data['true_cluster_id'] = list(true_cluster_ids)
        if plot_data_collection is None:
            plot_data_collection = plot_data
        else:
            for data_key in plot_data:
                plot_data_collection[data_key].extend(plot_data[data_key])
        ax = sns.scatterplot(x=[p[0] for p in learned_params],
                             y=[p[1] for p in learned_params],
                             palette=sns.color_palette(
                                 'Set2', len(np.unique(true_cluster_ids))),
                             hue=true_cluster_ids)
        ax.set(xlabel='Learned param 1', ylabel='Learned param 2')
        ax.set_title(k)
    pd.DataFrame(plot_data_collection).to_csv(plot_filepath + '_data.csv')
    pylab.subplots_adjust(hspace=0.3, wspace=0.4)
    output = six.StringIO()
    pylab.savefig(output, format='png')
    image = output.getvalue()
    with open(plot_filepath, 'w+') as f:
        f.write(image)
def pretty_template_plot(template, size=(18.5, 10.5), save=False, title=False,\
                        background=False):
    """
    Function to make a pretty plot of a single template, designed to work better
    than the default obspy plotting routine for short data lengths.

    :type template: :class: obspy.Stream
    :param template: Template stream to plot
    :type size: tuple
    :param size: tuple of plot size
    :type save: Boolean
    :param save: if False will plot to screen, if True will save
    :type title: Boolean
    :param title: String if set will be the plot title
    :type backrgound: :class: obspy.stream
    :param background: Stream to plot the template within.
    """
    fig, axes = plt.subplots(len(template), 1, sharex=True, figsize=size)
    if len(template) > 1:
        axes = axes.ravel()
    else:
        return
    if not background:
        mintime = template.sort(['starttime'])[0].stats.starttime
    else:
        mintime = background.sort(['starttime'])[0].stats.starttime
    template.sort(['network', 'station', 'starttime'])
    for i, tr in enumerate(template):
        delay = tr.stats.starttime - mintime
        delay *= tr.stats.sampling_rate
        y = tr.data
        x = np.arange(len(y))
        x += delay
        x = x / tr.stats.sampling_rate
        # x=np.arange(delay, (len(y)*tr.stats.sampling_rate)+delay,\
        # tr.stats.sampling_rate)
        if background:
            btr=background.select(station=tr.stats.station, \
                                channel=tr.stats.channel)[0]
            bdelay = btr.stats.starttime - mintime
            bdelay *= btr.stats.sampling_rate
            by = btr.data
            bx = np.arange(len(by))
            bx += bdelay
            bx = bx / btr.stats.sampling_rate
            axes[i].plot(bx, by, 'k', linewidth=1)
            axes[i].plot(x, y, 'r', linewidth=1.1)
        else:
            axes[i].plot(x, y, 'k', linewidth=1.1)
        print tr.stats.station + ' ' + str(len(x)) + ' ' + str(len(y))
        axes[i].set_ylabel(tr.stats.station + '.' + tr.stats.channel,
                           rotation=0)
        axes[i].yaxis.set_ticks([])
    axes[i - 1].set_xlabel('Time (s) from start of template')
    plt.subplots_adjust(hspace=0)
    if title:
        axes[0].set_title(title)
    if not save:
        plt.show()
        plt.close()
    else:
        plt.savefig(save)
Beispiel #48
0
        #Give a sample plot
        pl.subplot(337)
        bl = bls[0]
        i,j = np.argwhere(AntNos==bl[0]).squeeze(),np.argwhere(AntNos==bl[1]).squeeze()
        pl.vlines(D_ij[pol][bl]/bl_len[bl],0,1.1,color='k')
        pl.vlines((Tau[pol][i]-Tau[pol][j])/bl_len[bl],0,1.1,color='r')
        pl.vlines((-1,1),0,1.1,linestyles='dotted',color='k')
        pl.plot(delays/bl_len[bl],DD[pol][bl],'b')
        pl.title('Sample baseline, %d_%d'%bl)
        pl.xlim([-1.5,1.5])
        pl.ylim([0,1.1])
        pl.xlabel('Delay, baseline lenghth.')
        pl.ylabel('Amplitude')

        pl.subplots_adjust(wspace=0,hspace=0,top=0.95,bottom=0.05)
        pl.draw()
        figcnt += 1

    #Plot a matrix of all delays
    for pol in pols:
        pl.figure(figcnt)
        DDD = np.zeros((Nant,Nant))
        for i,ant1 in enumerate(AntNos):
            for j,ant2 in enumerate(AntNos):
                if not (ant1,ant2) in D_ij[pol].keys(): continue
                DDD[i,j] = D_ij[pol][(ant1,ant2)]
        DDD = np.ma.array(DDD,mask=np.where(DDD==0,1,0))
        pl.matshow(DDD,aspect='auto')
        pl.colorbar()
        pl.draw()
def plot_synth_real(real_template, synthetic, channels=False):
    """
    Plot multiple channels of data for real data and synthetic

    :type real_template: obspy.Stream
    :param real_template: Stream of the real template
    :type synthetic: obspy.Stream
    :param synthetic: Stream of synthetic template
    :type channels: List of str
    :param channels: List of tuples of (station, channel) to plot, default is\
            False, which plots all.
    """
    from obspy.signal.cross_correlation import xcorr
    from obspy import Stream
    colours = ['k', 'r']
    labels = ['Real', 'Synthetic']
    if channels:
        real = []
        synth = []
        for stachan in channels:
            real.append(real_template.select(station=stachan[0],\
                                             channel=stachan[1]))
            synth.append(synthetic.select(station=stachan[0],\
                                          channel=stachan[1]))
        real_template = Stream(real)
        synthetic = Stream(synth)

    # Extract the station and channels
    stachans = list(set([(tr.stats.station, tr.stats.channel)\
                         for tr in real_stream]))
    fig, axes = plt.subplots(len(stachans), 1, sharex=True, figsize=(5, 10))
    axes = axes.ravel()
    for i, stachan in enumerate(stachans):
        real_tr=real_template.select(station=stachan[0],\
                                     channel=stachan[1])[0]
        synth_tr=synthetic.select(station=stachan[0],\
                                           channel=stachan[1])[0]
        shift, corr = xcorr(real_tr, synth_tr, 2)
        print 'Shifting by: ' + str(shift) + ' samples'
        if corr < 0:
            synth_tr.data = synth_tr.data * -1
            corr = corr * -1
        if shift < 0:
            synth_tr.data = synth_tr.data[abs(shift):]
            real_tr.data = real_tr.data[0:len(synth_tr.data)]
        elif shift > 0:
            real_tr.data = real_tr.data[abs(shift):]
            synth_tr.data = synth_tr.data[0:len(real_tr.data)]
        for j, tr in enumerate([real_tr, synth_tr]):
            y = tr.data
            y = y / float(max(abs(y)))
            x = np.arange(0, len(y))
            x = x / tr.stats.sampling_rate
            axes[i].plot(x, y, colours[j], linewidth=2.0, label=labels[j])
            axes[i].get_yaxis().set_ticks([])
        axes[i].set_ylabel(stachan[0]+'.'+stachan[1]+' cc='+str(round(corr,2)),\
                           rotation=0)
    plt.subplots_adjust(hspace=0)
    # axes[0].legend()
    axes[-1].set_xlabel('Time (s)')
    plt.show()
Beispiel #50
0
for i in range(len(CELLS)):
    Rm_data[i] = 1e-6 / CELLS[i]['Gl']
    soma1, stick1, params1 = adjust_model_prop(Rm_data[i], soma, stick)

    Rtf_model[i] = get_the_mean_transfer_resistance_to_soma(
        soma1, stick1, params1)

print('---------------------------------------------------')
print('Comparison between model and data for Tm')
print('MODEL, mean = ', 1e-6 * Rtf_model.mean(), 'ms +/-',
      1e-6 * Rtf_model.std())
print('---------------------------------------------------')

fig, [ax, ax2] = plt.subplots(1, 2, figsize=(8, 3))
plt.subplots_adjust(bottom=.3, wspace=.4)
# histogram
# ax.hist(1e3*Rtf_data, color='r', label='data')
ax.hist(1e-6 * Rtf_model, color='b', label='model')
ax.legend(frameon=False, prop={'size': 'x-small'}, loc='best')
set_plot(ax,
         xlabel='transfer resistance \n to soma $(M \Omega)$',
         ylabel='cell #')
# correl Rm-Tm
ax2.plot(Rm_data, 1e-6 * Rtf_model, 'ob', label='model')
ax2.legend(prop={'size': 'xx-small'}, loc='best')
set_plot(ax2,
         xlabel='somatic input \n resistance $(M \Omega)$',
         ylabel='transfer resistance \n to soma $(M \Omega)$')
plt.show()
Beispiel #51
0
def select_windows(data_trace,
                   synthetic_trace,
                   event_latitude,
                   event_longitude,
                   event_depth_in_km,
                   station_latitude,
                   station_longitude,
                   minimum_period,
                   maximum_period,
                   min_cc=0.10,
                   max_noise=0.10,
                   max_noise_window=0.4,
                   min_velocity=2.4,
                   threshold_shift=0.30,
                   threshold_correlation=0.75,
                   min_length_period=1.5,
                   min_peaks_troughs=2,
                   max_energy_ratio=10.0,
                   min_envelope_similarity=0.2,
                   verbose=False,
                   plot=False):
    """
    Window selection algorithm for picking windows suitable for misfit
    calculation based on phase differences.

    Returns a list of windows which might be empty due to various reasons.

    This function is really long and a lot of things. For a more detailed
    description, please see the LASIF paper.

    :param data_trace: The data trace.
    :type data_trace: :class:`~obspy.core.trace.Trace`
    :param synthetic_trace: The synthetic trace.
    :type synthetic_trace: :class:`~obspy.core.trace.Trace`
    :param event_latitude: The event latitude.
    :type event_latitude: float
    :param event_longitude: The event longitude.
    :type event_longitude: float
    :param event_depth_in_km: The event depth in km.
    :type event_depth_in_km: float
    :param station_latitude: The station latitude.
    :type station_latitude: float
    :param station_longitude: The station longitude.
    :type station_longitude: float
    :param minimum_period: The minimum period of the data in seconds.
    :type minimum_period: float
    :param maximum_period: The maximum period of the data in seconds.
    :type maximum_period: float
    :param min_cc: Minimum normalised correlation coefficient of the
        complete traces.
    :type min_cc: float
    :param max_noise: Maximum relative noise level for the whole trace.
        Measured from maximum amplitudes before and after the first arrival.
    :type max_noise: float
    :param max_noise_window: Maximum relative noise level for individual
        windows.
    :type max_noise_window: float
    :param min_velocity: All arrivals later than those corresponding to the
        threshold velocity [km/s] will be excluded.
    :type min_velocity: float
    :param threshold_shift: Maximum allowable time shift within a window,
        as a fraction of the minimum period.
    :type threshold_shift: float
    :param threshold_correlation: Minimum normalised correlation coeeficient
        within a window.
    :type threshold_correlation: float
    :param min_length_period: Minimum length of the time windows relative to
        the minimum period.
    :type min_length_period: float
    :param min_peaks_troughs: Minimum number of extrema in an individual
        time window (excluding the edges).
    :type min_peaks_troughs: float
    :param max_energy_ratio: Maximum energy ratio between data and
        synthetics within a time window. Don't make this too small!
    :type max_energy_ratio: float
    :param min_envelope_similarity: The minimum similarity of the envelopes of
        both data and synthetics. This essentially assures that the
        amplitudes of data and synthetics can not diverge too much within a
        window. It is a bit like the inverse of the ratio of both envelopes
        so a value of 0.2 makes sure neither amplitude can be more then 5
        times larger than the other.
    :type min_envelope_similarity: float
    :param verbose: No output by default.
    :type verbose: bool
    :param plot: Create a plot of the algortihm while it does its work.
    :type plot: bool
    """
    # Shortcuts to frequently accessed variables.
    data_starttime = data_trace.stats.starttime
    data_delta = data_trace.stats.delta
    dt = data_trace.stats.delta
    npts = data_trace.stats.npts
    synth = synthetic_trace.data
    data = data_trace.data
    times = data_trace.times()

    # Fill cache if necessary.
    if not TAUPY_MODEL_CACHE:
        from obspy.taup import TauPyModel  # NOQA
        TAUPY_MODEL_CACHE["model"] = TauPyModel("AK135")
    model = TAUPY_MODEL_CACHE["model"]

    # -------------------------------------------------------------------------
    # Geographical calculations and the time of the first arrival.
    # -------------------------------------------------------------------------
    dist_in_deg = geodetics.locations2degrees(station_latitude,
                                              station_longitude,
                                              event_latitude, event_longitude)
    dist_in_km = geodetics.calcVincentyInverse(
        station_latitude, station_longitude, event_latitude,
        event_longitude)[0] / 1000.0

    # Get only a couple of P phases which should be the first arrival
    # for every epicentral distance. Its quite a bit faster than calculating
    # the arrival times for every phase.
    # Assumes the first sample is the centroid time of the event.
    tts = model.get_travel_times(source_depth_in_km=event_depth_in_km,
                                 distance_in_degree=dist_in_deg,
                                 phase_list=["ttp"])
    # Sort just as a safety measure.
    tts = sorted(tts, key=lambda x: x.time)
    first_tt_arrival = tts[0].time

    # -------------------------------------------------------------------------
    # Window settings
    # -------------------------------------------------------------------------
    # Number of samples in the sliding window. Currently, the length of the
    # window is set to a multiple of the dominant period of the synthetics.
    # Make sure it is an uneven number; just to have a trivial midpoint
    # definition and one sample does not matter much in any case.
    window_length = int(round(float(2 * minimum_period) / dt))
    if not window_length % 2:
        window_length += 1

    # Use a Hanning window. No particular reason for it but its a well-behaved
    # window and has nice spectral properties.
    taper = np.hanning(window_length)

    # =========================================================================
    # check if whole seismograms are sufficiently correlated and estimate
    # noise level
    # =========================================================================

    # Overall Correlation coefficient.
    norm = np.sqrt(np.sum(data**2)) * np.sqrt(np.sum(synth**2))
    cc = np.sum(data * synth) / norm
    if verbose:
        _log_window_selection(data_trace.id,
                              "Correlation Coefficient: %.4f" % cc)

    # Estimate noise level from waveforms prior to the first arrival.
    idx_end = int(np.ceil((first_tt_arrival - 0.5 * minimum_period) / dt))
    idx_end = max(10, idx_end)
    idx_start = int(np.ceil((first_tt_arrival - 2.5 * minimum_period) / dt))
    idx_start = max(10, idx_start)

    if idx_start >= idx_end:
        idx_start = max(0, idx_end - 10)

    abs_data = np.abs(data)
    noise_absolute = abs_data[idx_start:idx_end].max()
    noise_relative = noise_absolute / abs_data.max()

    if verbose:
        _log_window_selection(data_trace.id,
                              "Absolute Noise Level: %e" % noise_absolute)
        _log_window_selection(data_trace.id,
                              "Relative Noise Level: %e" % noise_relative)

    # Basic global rejection criteria.
    accept_traces = True
    if (cc < min_cc) and (noise_relative > max_noise / 3.0):
        msg = "Correlation %.4f is below threshold of %.4f" % (cc, min_cc)
        if verbose:
            _log_window_selection(data_trace.id, msg)
        accept_traces = msg

    if noise_relative > max_noise:
        msg = "Noise level %.3f is above threshold of %.3f" % (noise_relative,
                                                               max_noise)
        if verbose:
            _log_window_selection(data_trace.id, msg)
        accept_traces = msg

    # Calculate the envelope of both data and synthetics. This is to make sure
    # that the amplitude of both is not too different over time and is
    # used as another selector. Only calculated if the trace is generally
    # accepted as it is fairly slow.
    if accept_traces is True:
        data_env = obspy.signal.filter.envelope(data)
        synth_env = obspy.signal.filter.envelope(synth)

    # -------------------------------------------------------------------------
    # Initial Plot setup.
    # -------------------------------------------------------------------------
    # All the plot calls are interleaved. I realize this is really ugly but
    # the alternative would be to either have two functions (one with plots,
    # one without) or split the plotting function in various subfunctions,
    # neither of which are acceptable in my opinion. The impact on
    # performance is minimal if plotting is turned off: all imports are lazy
    # and a couple of conditionals are cheap.
    if plot:
        import matplotlib.pylab as plt  # NOQA
        import matplotlib.patheffects as PathEffects  # NOQA

        if accept_traces is True:
            plt.figure(figsize=(18, 12))
            plt.subplots_adjust(left=0.05,
                                bottom=0.05,
                                right=0.98,
                                top=0.95,
                                wspace=None,
                                hspace=0.0)
            grid = (31, 1)

            # Axes showing the data.
            data_plot = plt.subplot2grid(grid, (0, 0), rowspan=8)
        else:
            # Only show one axes it the traces are not accepted.
            plt.figure(figsize=(18, 3))

        # Plot envelopes if needed.
        if accept_traces is True:
            plt.plot(times,
                     data_env,
                     color="black",
                     alpha=0.5,
                     lw=0.4,
                     label="data envelope")
            plt.plot(synthetic_trace.times(),
                     synth_env,
                     color="#e41a1c",
                     alpha=0.4,
                     lw=0.5,
                     label="synthetics envelope")

        plt.plot(times, data, color="black", label="data", lw=1.5)
        plt.plot(synthetic_trace.times(),
                 synth,
                 color="#e41a1c",
                 label="synthetics",
                 lw=1.5)

        # Symmetric around y axis.
        middle = data.mean()
        d_max, d_min = data.max(), data.min()
        r = max(d_max - middle, middle - d_min) * 1.1
        ylim = (middle - r, middle + r)
        xlim = (times[0], times[-1])
        plt.ylim(*ylim)
        plt.xlim(*xlim)

        offset = (xlim[1] - xlim[0]) * 0.005
        plt.vlines(first_tt_arrival, ylim[0], ylim[1], colors="#ff7f00", lw=2)
        plt.text(first_tt_arrival + offset,
                 ylim[1] - (ylim[1] - ylim[0]) * 0.02,
                 "first arrival",
                 verticalalignment="top",
                 horizontalalignment="left",
                 color="#ee6e00",
                 path_effects=[
                     PathEffects.withStroke(linewidth=3, foreground="white")
                 ])

        plt.vlines(first_tt_arrival - minimum_period / 2.0,
                   ylim[0],
                   ylim[1],
                   colors="#ff7f00",
                   lw=2)
        plt.text(first_tt_arrival - minimum_period / 2.0 - offset,
                 ylim[0] + (ylim[1] - ylim[0]) * 0.02,
                 "first arrival - min period / 2",
                 verticalalignment="bottom",
                 horizontalalignment="right",
                 color="#ee6e00",
                 path_effects=[
                     PathEffects.withStroke(linewidth=3, foreground="white")
                 ])

        for velocity in [6, 5, 4, 3, min_velocity]:
            tt = dist_in_km / velocity
            plt.vlines(tt, ylim[0], ylim[1], colors="gray", lw=2)
            if velocity == min_velocity:
                hal = "right"
                o_s = -1.0 * offset
            else:
                hal = "left"
                o_s = offset
            plt.text(tt + o_s,
                     ylim[0] + (ylim[1] - ylim[0]) * 0.02,
                     str(velocity) + " km/s",
                     verticalalignment="bottom",
                     horizontalalignment=hal,
                     color="0.15")
        plt.vlines(dist_in_km / min_velocity + minimum_period / 2.0,
                   ylim[0],
                   ylim[1],
                   colors="gray",
                   lw=2)
        plt.text(dist_in_km / min_velocity + minimum_period / 2.0 - offset,
                 ylim[1] - (ylim[1] - ylim[0]) * 0.02,
                 "min surface velocity + min period / 2",
                 verticalalignment="top",
                 horizontalalignment="right",
                 color="0.15",
                 path_effects=[
                     PathEffects.withStroke(linewidth=3, foreground="white")
                 ])

        plt.hlines(noise_absolute,
                   xlim[0],
                   xlim[1],
                   linestyle="--",
                   color="gray")
        plt.hlines(-noise_absolute,
                   xlim[0],
                   xlim[1],
                   linestyle="--",
                   color="gray")
        plt.text(offset,
                 noise_absolute + (ylim[1] - ylim[0]) * 0.01,
                 "noise level",
                 verticalalignment="bottom",
                 horizontalalignment="left",
                 color="0.15",
                 path_effects=[
                     PathEffects.withStroke(linewidth=3, foreground="white")
                 ])
        plt.legend(loc="lower right",
                   fancybox=True,
                   framealpha=0.5,
                   fontsize="small")
        plt.gca().xaxis.set_ticklabels([])

        # Plot the basic global information.
        ax = plt.gca()
        txt = (
            "Total CC Coeff: %.4f\nAbsolute Noise: %e\nRelative Noise: %.3f" %
            (cc, noise_absolute, noise_relative))
        ax.text(0.01,
                0.95,
                txt,
                transform=ax.transAxes,
                fontdict=dict(fontsize="small", ha='left', va='top'),
                bbox=dict(boxstyle="round", fc="w", alpha=0.8))
        plt.suptitle("Channel %s" % data_trace.id, fontsize="larger")

        # Show plot and return if not accepted.
        if accept_traces is not True:
            txt = "Rejected: %s" % (accept_traces)
            ax.text(0.99,
                    0.95,
                    txt,
                    transform=ax.transAxes,
                    fontdict=dict(fontsize="small", ha='right', va='top'),
                    bbox=dict(boxstyle="round", fc="red", alpha=1.0))
            plt.show()
    if accept_traces is not True:
        return []

    # Initialise masked arrays. The mask will be set to True where no
    # windows are chosen.
    time_windows = np.ma.ones(npts)
    time_windows.mask = False
    if plot:
        old_time_windows = time_windows.copy()

    # Elimination Stage 1: Eliminate everything half a period before or
    # after the minimum and maximum travel times, respectively.
    # theoretical arrival as positive.
    min_idx = int((first_tt_arrival - (minimum_period / 2.0)) / dt)
    max_idx = int(
        math.ceil((dist_in_km / min_velocity + minimum_period / 2.0) / dt))
    time_windows.mask[:min_idx + 1] = True
    time_windows.mask[max_idx:] = True
    if plot:
        plt.subplot2grid(grid, (8, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="TRAVELTIME ELIMINATION")
        old_time_windows = time_windows.copy()

    # -------------------------------------------------------------------------
    # Compute sliding time shifts and correlation coefficients for time
    # frames that passed the traveltime elimination stage.
    # -------------------------------------------------------------------------
    # Allocate arrays to collect the time dependent values.
    sliding_time_shift = np.ma.zeros(npts, dtype="float32")
    sliding_time_shift.mask = True
    max_cc_coeff = np.ma.zeros(npts, dtype="float32")
    max_cc_coeff.mask = True

    for start_idx, end_idx, midpoint_idx in _window_generator(
            npts, window_length):
        if not min_idx < midpoint_idx < max_idx:
            continue

        # Slice windows. Create a copy to be able to taper without affecting
        # the original time series.
        data_window = data[start_idx:end_idx].copy() * taper
        synthetic_window = \
            synth[start_idx: end_idx].copy() * taper

        # Elimination Stage 2: Skip windows that have essentially no energy
        # to avoid instabilities. No windows can be picked in these.
        if synthetic_window.ptp() < synth.ptp() * 0.001:
            time_windows.mask[midpoint_idx] = True
            continue

        # Calculate the time shift. Here this is defined as the shift of the
        # synthetics relative to the data. So a value of 2, for instance, means
        # that the synthetics are 2 timesteps later then the data.
        cc = np.correlate(data_window, synthetic_window, mode="full")

        time_shift = cc.argmax() - window_length + 1
        # Express the time shift in fraction of the minimum period.
        sliding_time_shift[midpoint_idx] = (time_shift * dt) / minimum_period

        # Normalized cross correlation.
        max_cc_value = cc.max() / np.sqrt(
            (synthetic_window**2).sum() * (data_window**2).sum())
        max_cc_coeff[midpoint_idx] = max_cc_value

    if plot:
        plt.subplot2grid(grid, (9, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="NO ENERGY IN CC WINDOW")
        # Axes with the CC coeffs
        plt.subplot2grid(grid, (15, 0), rowspan=4)
        plt.hlines(0, xlim[0], xlim[1], color="lightgray")
        plt.hlines(-threshold_shift,
                   xlim[0],
                   xlim[1],
                   color="gray",
                   linestyle="--")
        plt.hlines(threshold_shift,
                   xlim[0],
                   xlim[1],
                   color="gray",
                   linestyle="--")
        plt.text(5,
                 -threshold_shift - (2) * 0.03,
                 "threshold",
                 verticalalignment="top",
                 horizontalalignment="left",
                 color="0.15",
                 path_effects=[
                     PathEffects.withStroke(linewidth=3, foreground="white")
                 ])
        plt.plot(times,
                 sliding_time_shift,
                 color="#377eb8",
                 label="Time shift in fraction of minimum period",
                 lw=1.5)
        ylim = plt.ylim()
        plt.yticks([-0.75, 0, 0.75])
        plt.xticks([300, 600, 900, 1200, 1500, 1800])
        plt.ylim(ylim[0], ylim[1] + ylim[1] - ylim[0])
        plt.ylim(-1.0, 1.0)
        plt.xlim(xlim)
        plt.gca().xaxis.set_ticklabels([])
        plt.legend(loc="lower right",
                   fancybox=True,
                   framealpha=0.5,
                   fontsize="small")

        plt.subplot2grid(grid, (10, 0), rowspan=4)
        plt.hlines(threshold_correlation,
                   xlim[0],
                   xlim[1],
                   color="0.15",
                   linestyle="--")
        plt.hlines(1, xlim[0], xlim[1], color="lightgray")
        plt.hlines(0, xlim[0], xlim[1], color="lightgray")
        plt.text(5,
                 threshold_correlation + (1.4) * 0.01,
                 "threshold",
                 verticalalignment="bottom",
                 horizontalalignment="left",
                 color="0.15",
                 path_effects=[
                     PathEffects.withStroke(linewidth=3, foreground="white")
                 ])
        plt.plot(times,
                 max_cc_coeff,
                 color="#4daf4a",
                 label="Maximum CC coefficient",
                 lw=1.5)
        plt.ylim(-0.2, 1.2)
        plt.yticks([0, 0.5, 1])
        plt.xticks([300, 600, 900, 1200, 1500, 1800])
        plt.xlim(xlim)
        plt.gca().xaxis.set_ticklabels([])
        plt.legend(loc="lower right",
                   fancybox=True,
                   framealpha=0.5,
                   fontsize="small")

    # Elimination Stage 3: Mark all areas where the normalized cross
    # correlation coefficient is under threshold_correlation as negative
    if plot:
        old_time_windows = time_windows.copy()
    time_windows.mask[max_cc_coeff < threshold_correlation] = True
    if plot:
        plt.subplot2grid(grid, (14, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="CORRELATION COEFF THRESHOLD ELIMINATION")

    # Elimination Stage 4: Mark everything with an absolute travel time
    # shift of more than # threshold_shift times the dominant period as
    # negative
    if plot:
        old_time_windows = time_windows.copy()
    time_windows.mask[np.ma.abs(sliding_time_shift) > threshold_shift] = True
    if plot:
        plt.subplot2grid(grid, (19, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="TIME SHIFT THRESHOLD ELIMINATION")

    # Elimination Stage 5: Mark the area around every "travel time shift
    # jump" (based on the traveltime time difference) negative. The width of
    # the area is currently chosen to be a tenth of a dominant period to
    # each side.
    if plot:
        old_time_windows = time_windows.copy()
    sample_buffer = int(np.ceil(minimum_period / dt * 0.1))
    indices = np.ma.where(np.ma.abs(np.ma.diff(sliding_time_shift)) > 0.1)[0]
    for index in indices:
        time_windows.mask[index - sample_buffer:index + sample_buffer] = True
    if plot:
        plt.subplot2grid(grid, (20, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="TIME SHIFT JUMPS ELIMINATION")

    # Clip both to avoid large numbers by division.
    stacked = np.vstack([
        np.ma.clip(synth_env,
                   synth_env.max() * min_envelope_similarity * 0.5,
                   synth_env.max()),
        np.ma.clip(data_env,
                   data_env.max() * min_envelope_similarity * 0.5,
                   data_env.max())
    ])
    # Ratio.
    ratio = stacked.min(axis=0) / stacked.max(axis=0)

    # Elimination Stage 6: Make sure the amplitudes of both don't vary too
    # much.
    if plot:
        old_time_windows = time_windows.copy()
    time_windows.mask[ratio < min_envelope_similarity] = True
    if plot:
        plt.subplot2grid(grid, (25, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="ENVELOPE AMPLITUDE SIMILARITY ELIMINATION")

    if plot:
        plt.subplot2grid(grid, (21, 0), rowspan=4)
        plt.hlines(min_envelope_similarity,
                   xlim[0],
                   xlim[1],
                   color="gray",
                   linestyle="--")
        plt.text(5,
                 min_envelope_similarity + (2) * 0.03,
                 "threshold",
                 verticalalignment="bottom",
                 horizontalalignment="left",
                 color="0.15",
                 path_effects=[
                     PathEffects.withStroke(linewidth=3, foreground="white")
                 ])
        plt.plot(times,
                 ratio,
                 color="#9B59B6",
                 label="Envelope amplitude similarity",
                 lw=1.5)
        plt.yticks([0, 0.2, 0.4, 0.6, 0.8, 1.0])
        plt.ylim(0.05, 1.05)
        plt.xticks([300, 600, 900, 1200, 1500, 1800])
        plt.xlim(xlim)
        plt.gca().xaxis.set_ticklabels([])
        plt.legend(loc="lower right",
                   fancybox=True,
                   framealpha=0.5,
                   fontsize="small")

    # First minimum window length elimination stage. This is cheap and if
    # not done it can easily destabilize the peak-and-trough marching stage
    # which would then have to deal with way more edge cases.
    if plot:
        old_time_windows = time_windows.copy()
    min_length = \
        min(minimum_period / dt * min_length_period, maximum_period / dt)
    for i in flatnotmasked_contiguous(time_windows):
        # Step 7: Throw away all windows with a length of less then
        # min_length_period the dominant periodele
        if (i.stop - i.start) < min_length:
            time_windows.mask[i.start:i.stop] = True
    if plot:
        plt.subplot2grid(grid, (26, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="MINIMUM WINDOW LENGTH ELIMINATION 1")

    # -------------------------------------------------------------------------
    # Peak and trough marching algorithm
    # -------------------------------------------------------------------------
    final_windows = []
    for i in flatnotmasked_contiguous(time_windows):
        # Cut respective windows.
        window_npts = i.stop - i.start
        synthetic_window = synth[i.start:i.stop]
        data_window = data[i.start:i.stop]

        # Find extrema in the data and the synthetics.
        data_p, data_t = find_local_extrema(data_window)
        synth_p, synth_t = find_local_extrema(synthetic_window)

        window_mask = np.ones(window_npts, dtype="bool")

        closest_peaks = find_closest(data_p, synth_p)
        diffs = np.diff(closest_peaks)

        for idx in np.where(diffs == 1)[0]:
            if idx > 0:
                start = synth_p[idx - 1]
            else:
                start = 0
            if idx < (len(synth_p) - 1):
                end = synth_p[idx + 1]
            else:
                end = -1
            window_mask[start:end] = False

        closest_troughs = find_closest(data_t, synth_t)
        diffs = np.diff(closest_troughs)

        for idx in np.where(diffs == 1)[0]:
            if idx > 0:
                start = synth_t[idx - 1]
            else:
                start = 0
            if idx < (len(synth_t) - 1):
                end = synth_t[idx + 1]
            else:
                end = -1
            window_mask[start:end] = False

        window_mask = np.ma.masked_array(window_mask, mask=window_mask)

        if window_mask.mask.all():
            continue

        for j in flatnotmasked_contiguous(window_mask):
            final_windows.append((i.start + j.start, i.start + j.stop))

    if plot:
        old_time_windows = time_windows.copy()
    time_windows.mask[:] = True
    for start, stop in final_windows:
        time_windows.mask[start:stop] = False
    if plot:
        plt.subplot2grid(grid, (27, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="PEAK AND TROUGH MARCHING ELIMINATION")

    # Loop through all the time windows, remove windows not satisfying the
    # minimum number of peaks and troughs per window. Acts mainly as a
    # safety guard.
    old_time_windows = time_windows.copy()
    for i in flatnotmasked_contiguous(old_time_windows):
        synthetic_window = synth[i.start:i.stop]
        data_window = data[i.start:i.stop]
        data_p, data_t = find_local_extrema(data_window)
        synth_p, synth_t = find_local_extrema(synthetic_window)
        if np.min([len(synth_p), len(synth_t), len(data_p), len(data_t)]) < \
                min_peaks_troughs:
            time_windows.mask[i.start:i.stop] = True
    if plot:
        plt.subplot2grid(grid, (28, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="PEAK/TROUGH COUNT ELIMINATION")

    # Second minimum window length elimination stage.
    if plot:
        old_time_windows = time_windows.copy()
    min_length = \
        min(minimum_period / dt * min_length_period, maximum_period / dt)
    for i in flatnotmasked_contiguous(time_windows):
        # Step 7: Throw away all windows with a length of less then
        # min_length_period the dominant period.
        if (i.stop - i.start) < min_length:
            time_windows.mask[i.start:i.stop] = True
    if plot:
        plt.subplot2grid(grid, (29, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="MINIMUM WINDOW LENGTH ELIMINATION 2")

    # Final step, eliminating windows with little energy.
    final_windows = []
    for j in flatnotmasked_contiguous(time_windows):
        # Again assert a certain minimal length.
        if (j.stop - j.start) < min_length:
            continue

        # Compare the energy in the data window and the synthetic window.
        data_energy = (data[j.start:j.stop]**2).sum()
        synth_energy = (synth[j.start:j.stop]**2).sum()
        energies = sorted([data_energy, synth_energy])
        if energies[1] > max_energy_ratio * energies[0]:
            if verbose:
                _log_window_selection(
                    data_trace.id,
                    "Deselecting window due to energy ratio between "
                    "data and synthetics.")
            continue

        # Check that amplitudes in the data are above the noise
        if noise_absolute / data[j.start: j.stop].ptp() > \
                max_noise_window:
            if verbose:
                _log_window_selection(
                    data_trace.id,
                    "Deselecting window due having no amplitude above the "
                    "signal to noise ratio.")
        final_windows.append((j.start, j.stop))

    if plot:
        old_time_windows = time_windows.copy()
    time_windows.mask[:] = True
    for start, stop in final_windows:
        time_windows.mask[start:stop] = False

    if plot:
        plt.subplot2grid(grid, (30, 0), rowspan=1)
        _plot_mask(time_windows,
                   old_time_windows,
                   name="LITTLE ENERGY ELIMINATION")

    if verbose:
        _log_window_selection(
            data_trace.id, "Done, Selected %i window(s)" % len(final_windows))

    # Final step is to convert the index value windows to actual times.
    windows = []
    for start, stop in final_windows:
        start = data_starttime + start * data_delta
        stop = data_starttime + stop * data_delta
        windows.append((start, stop))

    if plot:
        # Plot the final windows to the data axes.
        import matplotlib.transforms as mtransforms  # NOQA
        ax = data_plot
        trans = mtransforms.blended_transform_factory(ax.transData,
                                                      ax.transAxes)
        for start, stop in final_windows:
            ax.fill_between([start * data_delta, stop * data_delta],
                            0,
                            1,
                            facecolor="#CDDC39",
                            alpha=0.5,
                            transform=trans)

        plt.show()

    return windows
Beispiel #52
0
y = np.r_[0:1:0.1, 9:10:0.1]

#fig,(ax,ax2) = plt.subplots(1, 2, sharey=True)
fig,(ax2,ax) = plt.subplots(2, 1, sharex=True)

# plot the same data on both axes
ax.plot(x, y, 'bo')
ax2.plot(x, y, 'bo')

# zoom-in / limit the view to different portions of the data
#ax.set_xlim(0,1) # most of the data
ax.set_ylim(0,1) # most of the data
#ax2.set_xlim(9,10) # outliers only
ax2.set_ylim(9,10) # outliers only

# hide the spines between ax and ax2
#ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
#ax2.spines['left'].set_visible(False)
ax2.spines['bottom'].set_visible(False)
ax.yaxis.tick_left()
ax.tick_params(labeltop='off') # don't put tick labels at the top
#ax2.yaxis.tick_right()
ax2.yaxis.tick_left()

# Make the spacing between the two axes a bit smaller
plt.subplots_adjust(wspace=0.15)

plt.show()

        noise_scale)

    theta[t, :] = theta_next.reshape(1, Nosc)
    phase_dynamics[t, :] = func_oscillator_approx_fourier_series(
        theta[t, :], K1, K2, omega)

    for i in range(Nosc):
        theta_unwrap = np.unwrap(deepcopy(theta[t - 1:t + 1, i]))

        dtheta[t, i] = (theta_unwrap[1] - theta_unwrap[0]) / h
#%% plot phase
axis = np.arange(theta.shape[0])

fig = plt.figure(figsize=(20, 8))
gs = fig.add_gridspec(Nosc, 1)
plt.subplots_adjust(wspace=0.4, hspace=0.0)

for n in range(Nosc):
    #####################
    ax11 = fig.add_subplot(gs[n, 0])
    plt.plot(axis, theta[:, n])

    plt.ylabel('$\\phi_{%d}$' % (n + 1))
    plt.xticks(np.arange(0, Nt + 1, int(
        Nt / 2)))  # plt.xticks(np.arange(0, Nt+1, int(Nt/3)))
    plt.yticks([0, np.pi, 2 * np.pi], labels=['0', '$\\pi$', '$2 \\pi$'])
    plt.grid()

plt.xlabel('# sample')

plt.show()
Beispiel #54
0
    plt.ylabel("Correlation", fontsize=12)
    plt.ylim([-0.65, 1.])
    plt.yticks([-0.6, -0.4, -0.2, 0., 0.2, 0.4, 0.6, 0.8, 1.], fontsize=12)
    plt.axhline(y=0., color='k', linestyle='-', linewidth=2.)
    plt.xlim([-3., 3.])
    plt.xlabel("Lag [years]", fontsize=12)

    return 0


ti = np.arange(-float(t / 12) + 1. / 12, float(t / 12) - 1. / 12., 1. / 12.)

fig = plt.figure(figsize=(10, 10))
ax = plt.subplots_adjust(left=0.1,
                         right=0.98,
                         bottom=0.06,
                         top=0.95,
                         hspace=0.35,
                         wspace=0.3)

titles = [
    "Tropical mean - Low clouds", "Nino3.4 region - Low clouds",
    "Nino3.4 region - Tropical mean", "Low clouds - Tropical cloud cover"
]

for i in range(4):
    ax = plt.subplot(2, 2, i + 1)
    plt.title(titles[i])
    for j in range(m):
        plt.plot(t, corr[j, i], 'k', alpha=0.2)
    plt.plot(t, np.median(corr[:, i], axis=0), 'k', linewidth=2.)
Beispiel #55
0
                #plt.scatter(z_samples[i,:,0],z_samples[i,:,1])
                plt.axis('square');
                plt.title('q(z|x={})'.format(y[i]))
                plt.xlim([xmin,xmax])
                plt.ylim([xmin,xmax])
                plt.xticks([])
                plt.yticks([]);
                plt.subplot(2,5,5+i+1)
                plt.contour(xrange, xrange, np.exp(logprior+llh[i]).reshape(300,300).T, cmap='Greens')
                plt.axis('square');
                plt.title('p(z|x={})'.format(y[i]))
                plt.xlim([xmin,xmax])
                plt.ylim([xmin,xmax])
                plt.xticks([])
                plt.yticks([]);
            plt.text(-60,20,'KLR Loss: %f, NELBO: %f, KL0: %f, KL1: %f, KL2: %f, KL3: %f, KL4: %f' % (dl, NELBO, KL0, KL1, KL2, KL3, KL4))
            plt.text(-28,-7,'KLAVG: %f' %(KLAVG))
            plt.savefig('FiguresJCKL\Fig %i'%(j))
            plt.close()
    plt.subplot(2,1,1)
    plt.plot(KLAVGBRUH)
    plt.xlabel('Iterations (x100)')
    plt.ylabel('Avg KL Div')
    plt.subplot(2,1,2)
    plt.plot(ISTHISLOSS)
    plt.xlabel('Iterations (x100)')
    plt.ylabel('KLR Loss')
    plt.subplots_adjust(top=0.95,bottom=0.15,right=0.95,hspace=0.4)
    plt.savefig('FiguresJCKL\Diag Plot', bbox_inches='tight')
    plt.close()
plt.rc('ytick.minor', width=2.0)
plt.rc('lines', markersize=8, markeredgewidth=0.0, linewidth=2.0)

#plt.rcParams['ps.fonttype'] = 42
#plt.rcParams['pdf.fonttype'] = 42

fig = plt.figure(num=1, figsize=(9, 7), dpi=600, facecolor='w', edgecolor='k')
left = 0.10  # the left side of the subplots of the figure
right = 0.94  # the right side of the subplots of the figure
bottom = 0.1  # the bottom of the subplots of the figure
top = 0.96  # the top of the subplots of the figure
wspace = 0.2  # the amount of width reserved for blank space between subplots
hspace = 0.0  # the amount of height reserved for white space between subplots
plt.subplots_adjust(left=left,
                    bottom=bottom,
                    right=right,
                    top=top,
                    wspace=wspace,
                    hspace=hspace)

ax1 = plt.subplot(1, 1, 1)
hist = plt.hist(
    peak_sep_arr_norm,
    bins=binarr,
    weights=np.ones(len(peak_sep_arr_norm)) / len(peak_sep_arr_norm),
    density=False
)  #note weights and density arguement make total of y values 1, regardless of bin values
plt.xticks(binarr, fontsize=12)
plt.yticks(fontsize=12)
plt.ylim(0, 0.25)
plt.xlabel(r'Period/$\tau_{dyn}^{' + galaxyname + '}$', fontsize=15)
plt.ylabel('Fraction of Orbits', fontsize=15)
Beispiel #57
0
import numpy as np
from scipy.linalg import expm
import matplotlib.pylab as plt

if __name__ == '__main__':
    A = np.array([[-1, 1], [0, -1]])
    B = np.array([[-1, 5], [0, -2]])

    t = np.linspace(0.1, 5, 50)

    norm_a, norm_b = [], []
    for i in t:
        norm_a.append(np.linalg.norm(expm(A * i)))
        norm_b.append(np.linalg.norm(expm(B * i)))

    plt.xkcd()
    fig = plt.figure()
    ax = fig.add_subplot(111)
    plt.subplots_adjust(bottom=0.15, left=0.15)

    ax.plot(norm_a, 'b')
    ax.plot(norm_b, 'k')
    ticks = ax.get_xticks().astype('i')
    ax.set_xticklabels(ticks, fontsize=16, weight='bold')
    ticks = ax.get_yticks()
    ax.set_yticklabels(ticks, fontsize=16, weight='bold')
    ax.set_xlabel('Time', fontsize=18, weight='bold')
    ax.set_ylabel(r'$||exp(At)||$', fontsize=18, weight='bold')
    plt.savefig('spectra.pdf', axis='tight')
    plt.show()
Beispiel #58
0
def display_collision3D(collision, fig=None, ax=None, color_blind=False):

    if fig is None:
        fig = plt.figure(figsize=(6, 4), dpi=100)

    if ax is None:
        ax = fig.add_subplot(1, 1, 1)
        ax = fig.gca(projection='3d')
        plt.subplots_adjust(top=0.98, bottom=0.02, right=0.98, left=0.02)

    jets, muons, electrons, photons, met = collision

    lines = draw_beams()
    if (color_blind == False):
        pmom = np.array(jets).transpose()[1:4].transpose()
        origin = np.zeros((len(jets), 3))
        lines += draw_jet3D(origin=origin, pmom=pmom)

        pmom = np.array(muons).transpose()[1:4].transpose()
        origin = np.zeros((len(muons), 3))
        lines += draw_muon3D(origin=origin, pmom=pmom)

        pmom = np.array(electrons).transpose()[1:4].transpose()
        origin = np.zeros((len(electrons), 3))
        lines += draw_electron3D(origin=origin, pmom=pmom)

        pmom = np.array(photons).transpose()[1:4].transpose()
        origin = np.zeros((len(photons), 3))
        lines += draw_photon3D(origin=origin, pmom=pmom)
    if (color_blind == True):
        pmom = np.array(jets).transpose()[1:4].transpose()
        origin = np.zeros((len(jets), 3))
        lines += draw_jet3D(origin=origin, pmom=pmom, ls='solid', color='gray')

        pmom = np.array(muons).transpose()[1:4].transpose()
        origin = np.zeros((len(muons), 3))
        lines += draw_muon3D(origin=origin,
                             pmom=pmom,
                             ls='dashed',
                             color='black')

        pmom = np.array(electrons).transpose()[1:4].transpose()
        origin = np.zeros((len(electrons), 3))
        lines += draw_electron3D(origin=origin,
                                 pmom=pmom,
                                 ls='dashed',
                                 color='gray')

        pmom = np.array(photons).transpose()[1:4].transpose()
        origin = np.zeros((len(photons), 3))
        lines += draw_photon3D(origin=origin,
                               pmom=pmom,
                               ls='solid',
                               color='black')

    for l in lines:
        ax.add_line(l)

    ax.set_xlim(-200, 200)
    ax.set_ylim(-200, 200)
    ax.set_zlim(-200, 200)
    def plot_div(self, show=True, save=False):
        init_div = svf.SpiralVectorField.get_divergence(self.u, self.v)
        reg_div = svf.SpiralVectorField.get_divergence(self.ur, self.vr)
        diff = init_div - reg_div

        plot_extent = [self.x.min(), self.x.max(), self.y.min(), self.y.max()]

        fig8 = pl.figure(figsize=(self.figW, self.figH))

        plot = fig8.add_subplot(1, 3, 1, aspect='equal')
        im1 = plot.imshow(init_div,
                          vmin=-0.5,
                          vmax=0.5,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.set_title("Initial Divergence",
                       size=self.text_size,
                       pad=self.title_pad)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        plot.tick_params(labelsize=self.tick_label_size)
        cbar = fig8.colorbar(im1, fraction=0.046, pad=0.04)
        cbar.ax.tick_params(labelsize=self.cbar_label_size)

        plot = fig8.add_subplot(1, 3, 2, aspect='equal')
        im2 = plot.imshow(reg_div,
                          vmin=-0.5,
                          vmax=0.5,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.set_title("GPR Model Divergence",
                       size=self.text_size,
                       pad=self.title_pad)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        plot.tick_params(labelsize=self.tick_label_size)
        cbar = fig8.colorbar(im2, fraction=0.046, pad=0.04)
        cbar.ax.tick_params(labelsize=self.cbar_label_size)

        plot = fig8.add_subplot(1, 3, 3, aspect='equal')
        im3 = plot.imshow(diff,
                          vmin=-0.5,
                          vmax=0.5,
                          origin='center',
                          extent=plot_extent,
                          cmap='jet')
        plot.set_title("Divergence Error",
                       size=self.text_size,
                       pad=self.title_pad)
        plot.set_xlim(-5, 5)
        plot.set_ylim(-5, 5)
        plot.tick_params(labelsize=self.tick_label_size)
        cbar = fig8.colorbar(im3, fraction=0.046, pad=0.04)
        cbar.ax.tick_params(labelsize=self.cbar_label_size)

        pl.subplots_adjust(left=0.06,
                           bottom=0.47,
                           right=0.94,
                           top=0.88,
                           wspace=0.48,
                           hspace=0.0)

        if show:
            pl.show()

        if save:
            fig8.savefig("divergence.png", dpi=300)
Beispiel #60
0
del ode, J, x, ts

try:
    from matplotlib import pylab
except ImportError:
    print("matplotlib not available")
    raise SystemExit

import numpy as np
ii = np.asarray([v[0] for v in history])
tt = np.asarray([v[1] for v in history])
xx = np.asarray([v[2] for v in history])

pylab.suptitle('Rober')
pylab.subplot(2, 2, 1)
pylab.subplots_adjust(wspace=0.3)
pylab.semilogy(
    ii[:-1],
    np.diff(tt),
)
pylab.xlabel('step number')
pylab.ylabel('timestep')

for i in range(0, 3):
    pylab.subplot(2, 2, i + 2)
    pylab.semilogx(tt, xx[:, i], "rgb"[i])
    pylab.xlabel('t')
    pylab.ylabel('x%d' % i)

pylab.show()