Exemple #1
0
    def plot_peak_altitude(self, ax=None, true_color='k',
            apparent_color='grey'):
        if ax is None:
            ax = plt.gca()
        plt.sca(ax)

        for d in self.digitization_list:
            if d.is_invertible():
                if d.altitude.size == 0:
                    try:
                        d.invert(substitute_fp=ais_code.ne_to_fp(4.))
                    except BaseException as e:
                        print(e)
                        continue

                if apparent_color:
                    plt.plot(d.time, d.altitude[-1], marker='.',
                        ms=self.marker_size, color=apparent_color)
                alt = mex.iau_pgr_alt_lat_lon_position(float(d.time))[0]
                plt.plot(d.time,
                alt - d.traced_delay[-1] * ais_code.speed_of_light_kms / 2.,
                        marker='.', color=true_color,
                        ms=self.marker_size)
        celsius.ylabel(r'$h_{max} / km$')
        plt.ylim(0o1, 249)
Exemple #2
0
 def plot_r(self, ax=None, label=True, fmt='k-', **kwargs):
     if ax is None:
         ax = plt.gca()
     plt.sca(ax)
     self.generate_position()
     plt.plot(self.t, self.iau_pos[0] / mex.mars_mean_radius_km, fmt, **kwargs)
     celsius.ylabel(r'$r / R_M$')
Exemple #3
0
    def plot_timeseries(self, ax=None, vmin=None, vmax=None,
            colorbar=False, label=True):

        if vmin is None:
            vmin = self.vmin

        if vmax is None:
            vmax = self.vmax

        if ax is None:
            ax = plt.gca()
        plt.sca(ax)
        plt.cla()
        plt.imshow(self.tser_arr[::-1,:], vmin=vmin, vmax=vmax,
            interpolation='Nearest', extent=self.extent, origin='upper',aspect='auto')
        plt.xlim(self.extent[0], self.extent[1])
        plt.ylim(self.extent[2], self.extent[3])
        # plt.vlines(self.ionogram_list[0].time, self.extent[2], self.extent[3], 'r')
        if label:
           celsius.ylabel('f / MHz')

        if colorbar:
            old_ax = plt.gca()
            plt.colorbar(
                    cax = celsius.make_colorbar_cax(), ticks=self.cbar_ticks
                ).set_label(r"$Log_{10} V^2 m^{-2} Hz^{-1}$")
            plt.sca(old_ax)
Exemple #4
0
def plot_matches_group(g,how='chi',ntop=8):
    """
    Plot matches from h5 group

    Pulls out the relavent arrays from a group and runs plot_matches
    
    Parameters
    ----------
    g : h5 group containing the following datasets
        - arr : DataSet with spectra
        - smres : DataSet with specmatch results
    
    """
    smres = pd.DataFrame(g['smres'][:])
    smres = results.smres_add_chi(smres)

    lspec = g['lspec'][:]
    smres.index = np.arange(len(smres))

    if how=='chi':
        smresbest = smres.sort_values(by='chi')
    elif how=='close':
        targname = smio.kbc_query(smres.targobs[0])['name']
        tpar = dict(lib.ix[targname])
        smres['close'] = close(tpar,smres)
        smresbest = smres.sort_values(by='close')
    smresbest = smresbest.iloc[:ntop]

    plot_matches(smresbest,lspec)
    plt.sca(plt.gcf().get_axes()[0])
Exemple #5
0
def orbit_plots(orbit_list=[8020, 8021, 8022, 8023, 8024, 8025], resolution=200, ax=None):

    if ax is None:
        ax = plt.gca()
    plt.sca(ax)

    orbits = {}
    props = dict(marker="None", hold=True, mec=None, linestyle="-", markeredgewidth=0.0)
    # props = dict(marker='o', hold=True,mec='None',line style='None',markeredgewidth=0.0)

    for orbit in orbit_list:
        orbit_t = mex.orbits[orbit]
        print(orbit, orbit_t.start, orbit_t.finish)
        t = np.linspace(orbit_t.start, orbit_t.finish, resolution)
        pos = mex.iau_pgr_alt_lat_lon_position(t)
        # orbits[orbit] = dict(lat = np.rad2deg(pos[2]), lon = np.rad2deg(np.unwrap(pos[1])),
        #                         alt=pos[0] - mex.mars_mean_radius_km, t=t)
        orbits[orbit] = dict(lat=pos[1], lon=np.rad2deg(np.unwrap(np.deg2rad(pos[2]))), alt=pos[0], t=t)

        ll = plt.plot(orbits[orbit]["lon"], orbits[orbit]["lat"], label=str(orbit), **props)

        plt.plot(
            orbits[orbit]["lon"] + 360.0, orbits[orbit]["lat"], label="_nolegend_", color=ll[0].get_color(), **props
        )
        plt.plot(
            orbits[orbit]["lon"] - 360.0, orbits[orbit]["lat"], label="_nolegend_", color=ll[0].get_color(), **props
        )

    plt.xlim(-180, 180)
    plt.ylim(-90, 90)
    plt.xlabel("Longitude / deg")
    plt.ylabel("Latitude / deg")
    plt.legend(loc="center left", bbox_to_anchor=(1.01, 0.5), numpoints=1, title="Orbit")
    ax.xaxis.set_major_locator(celsius.CircularLocator())
    ax.yaxis.set_major_locator(celsius.CircularLocator())
Exemple #6
0
    def plot_acf_ccf(axacf,axccf,wlo,whi):
        b = (w > wlo) & (w < whi)
        plt.sca(axccf)
        dvmax = plot_ccf(w[b], tspec[b], mspec[b])

        plt.sca(axacf)
        thwhm,mhwhm = plot_acf(w[b], tspec[b], mspec[b])
        return dvmax,thwhm,mhwhm
Exemple #7
0
 def plot_altitude(self, ax=None, label=True, fmt='k-', **kwargs):
     if ax is None:
         ax = plt.gca()
     plt.sca(ax)
     self.generate_position()
     plt.plot(self.t, self.iau_pos[0] - mex.mars_mean_radius_km, fmt, **kwargs)
     if label:
         celsius.ylabel('h / km')
Exemple #8
0
 def setlims(d):
     plt.sca(d['ax'])
     xk = d['xk']
     yk = d['yk']
     if limd.keys().count(xk)==1:
         plt.xlim(*limd[xk])
     if limd.keys().count(yk)==1:
         plt.ylim(*limd[yk])
Exemple #9
0
 def plot_sza(self, ax=None, label=True, fmt='k-', **kwargs):
     if ax is None:
         ax = plt.gca()
     plt.sca(ax)
     self.make_axis_circular(ax)
     self.generate_position()
     plt.plot(self.t, self.sza, fmt, **kwargs)
     if label:
         celsius.ylabel(r'$SZA / deg$')
     plt.ylim(0., 180.)
Exemple #10
0
 def plot_lat(self, ax=None, label=True, fmt='k-', **kwargs):
     if ax is None:
         ax = plt.gca()
     plt.sca(ax)
     self.make_axis_circular(ax)
     self.generate_position()
     plt.plot(self.t, self.iau_pos[1], fmt, **kwargs)
     if label:
         celsius.ylabel(r'$\lambda$')
     plt.ylim(-90., 90.)
Exemple #11
0
 def flipax(d):
     plt.sca(d['ax'])
     xk = d['xk']
     yk = d['yk']
     if flipd.keys().count(xk)==1:
         if flipd[xk]:
             flip('x')
     if flipd.keys().count(yk)==1:
         if flipd[yk]:
             flip('y')
Exemple #12
0
    def plot_mod_b(self, fmt='k.', ax=None,
                    field_model=True, errors=True, field_color='blue',
                    br=True, t_offset=0., label=True, **kwargs):
        if ax is None:
            ax = plt.gca()
        plt.sca(ax)

        sub = [d for d in self.digitization_list if np.isfinite(d.td_cyclotron)]
        if len(sub) == 0:
            print("No digitizations with marked cyclotron frequency lines")
            return

        t = np.array([d.time for d in sub])
        b = np.array([d.td_cyclotron for d in sub])
        e = np.array([d.td_cyclotron_error for d in sub])
        # print b
        # print e

        b, e = ais_code.td_to_modb(b, e)
        b *= 1.E9
        e *= 1.E9

        if errors:
            for tt,bb,ee in zip(t,b,e):
                plt.plot((tt,tt),(bb+ee,bb-ee),
                                color='lightgrey',linestyle='solid',marker='None')
                plt.plot(tt,bb,fmt,ms=self.marker_size, **kwargs)
            # plt.errorbar(t, b, e, fmt=fmt, ms=self.marker_size, **kwargs)
        else:
            plt.plot(t, b, fmt, ms=self.marker_size, **kwargs)

        if field_model:
            self.generate_position()

            if field_color is None: field_color = fmt[0]
            # b = self.quick_field_model(self.t)
            self._computed_field_model = self.field_model(self.iau_pos)
            bmag = np.sqrt(np.sum(self._computed_field_model**2., 0))
            plt.plot(self.t - t_offset,
                        bmag,
                        color=field_color, ls='-')
            if br:
                plt.plot(self.t - t_offset,
                    self._computed_field_model[0], 'r-')
                plt.plot(self.t - t_offset,
                    -1. * self._computed_field_model[0], 'r', ls='dashed')

            model_at_value = np.interp(t, self.t, bmag)
            inx = (model_at_value > 100.) & ((b / model_at_value) < 0.75)
            plt.plot(t[inx], b[inx], 'ro', mec='r', mfc='none', ms=5., mew=1.2)


        if label:
            celsius.ylabel(r'$\mathrm{|B|/nT}$')
        plt.ylim(0., 200)
Exemple #13
0
def velocityshift(wav, flux, ref_wav, ref_flux, plot=False):
    """
    Find the velocity shift between two spectra. 

    Args:
        wav (array): Wavelength array.
        flux (array): Continuum-normalized spectrum. 
        ref_wav (array): 
        ref_flux (array): 
    
    Returns:
        vmax (float): Velocity of the cross-correlation peak. Positive velocity
            means that observed spectrum is red-shifted with respect to the 
            reference spectrum.
         corrmax (float): Peak cross-correlation amplitude.
    """
    nwav = flux.size

    # Build spline object for resampling the model spectrum
    ref_spline = InterpolatedUnivariateSpline(ref_wav, ref_flux)

    # Convert target and model spectra to constant log-lambda scale
    wav, flux, dvel = loglambda(wav, flux)
    ref_flux = ref_spline(wav)

    # Perform cross-correlation, and use quadratic interpolation to
    # find the velocity value that maximizes the cross-correlation
    # amplitude. If `lag` is negative, the observed spectrum need to
    # be blue-shifted in order to line up with the observed
    # spectrum. Thus, to put the spectra on the same scale, the
    # observed spectrum must be red-shifted, i.e. vmax is positive.
    flux-=np.mean(flux)
    ref_flux-=np.mean(ref_flux)
    lag = np.arange(-nwav + 1, nwav) 
    dvel = -1.0 * lag * dvel
    corr = np.correlate(ref_flux, flux, mode='full')
    vmax, corrmax = quadratic_max(dvel, corr)

    if plot:
        from matplotlib import pylab as plt
        fig,axL = plt.subplots(ncols=2)
        plt.sca(axL[0])
        plt.plot(wav,ref_flux)
        plt.plot(wav,flux)
        plt.sca(axL[1])
        vrange = (-100,100)
        b = (dvel > vrange[0]) & (dvel < vrange[1])
        plt.plot(dvel[b],corr[b])
        plt.plot([vmax],[corrmax],'o',label='Cross-correlation Peak')
        fig.set_tight_layout(True)
        plt.draw()
        plt.show()

    return vmax, corrmax
Exemple #14
0
def test_axes_stuff():
    fig = DJAPage(ratios=[2.,1., 0.63])
    plt.sca(fig.top_axes)
    x = np.arange(360.)
    y = np.sin(x * np.pi/180. + 2.)
    plt.plot(x, y, 'r-')
    plt.sca(fig.bottom_axes)
    mb = add_labelled_bar(x,x)
    fig.register_new_axis(mb)
    plt.xlim(0., 360.)
    plt.show()
Exemple #15
0
 def plotline(x):
     ax = x['ax']
     xk = x['xk']
     plt.sca(ax)
     trans = blended_transform_factory(ax.transData,ax.transAxes)
     plt.axvline(smpar[xk],ls='--')
     plt.text(smpar[xk],0.9,'SM',transform=trans)
     
     if libpar is not None:
         plt.axvline(libpar[xk])
         plt.text(libpar[xk],0.9,'LIB',transform=trans)
Exemple #16
0
 def wrapped_f(*args):
     for ax in axL:                
         plt.sca(ax)
         f(*args)
     xl = plt.xlim()
     start = xl[0]
     step = (xl[1]-xl[0]) / float(nax)
     for ax in axL:                
         plt.sca(ax)
         plt.xlim(start,start+step)
         start+=step
Exemple #17
0
 def plot_aspera_els(self, ax=None, **kwargs):
     if self.verbose: print('PLOT_ASPERA_ELS:')
     if ax is None:
         ax = plt.gca()
     else:
         plt.sca(ax)
     try:
         mex.aspera.plot_els_spectra(self.extent[0], self.extent[1],
             ax=ax, verbose=self.verbose, **kwargs)
     except Exception as e:
         print(e)
Exemple #18
0
    def plot_profiles(self, ax=None, vmin=4., vmax=5.5, cmap=None,
                                cmticks=None, log=True, substitute_fp=None, **kwargs):
        """
        Inverts the profiles, plots them versus time and altitude, color coded to density
        Does not show the 'first step' between the S/C plasma density and the first reflection
        """
        if ax is None:
            ax = plt.gca()
        plt.sca(ax)
        ax.set_axis_bgcolor("gray")

        if cmap is None:
            cmap = matplotlib.cm.hot
        if cmticks is None:
            cmticks = [3, 4, 5, 6]
        n_profiles = int((self.extent[1] - self.extent[0]) / ais_code.ais_spacing_seconds) + 1
        ranges = np.arange(80., 350., 1.)
        times  = np.arange(self.extent[0], self.extent[1], ais_code.ais_spacing_seconds)
        img = np.zeros((len(times), len(ranges))) + np.nan

        label = r'$n_e$ / cm$^{-3}$'
        if log:
            f = np.log10
            label = r'log ' + label
        else:
            f = lambda x: x

        if substitute_fp is None:
            subf = lambda t: 0.
        else:
            if hasattr(substitute_fp, '__call__'):
                subf = lambda t: substitute_fp(t)
            else:
                subf = lambda t: substitute_fp

        for i, d in enumerate(self.digitization_list):
            if d.is_invertible():
                d.invert(substitute_fp=subf(d.time))
                if d.altitude.size:
                    ii = round((float(d.time) - times[0]) / ais_code.ais_spacing_seconds)
                    img[ii,:] = np.interp(ranges, d.altitude[-1:0:-1],
                                            f(d.density[-1:0:-1]),
                                            right=np.nan, left=np.nan)[::-1]

        extent = (self.extent[0], self.extent[1], np.nanmin(ranges), np.nanmax(ranges))
        plt.imshow(img.T, interpolation='Nearest', extent=extent,
                origin='upper',aspect='auto', vmin=vmin, vmax=vmax, cmap=cmap)

        celsius.ylabel("alt / km")

        old_ax = plt.gca()
        plt.colorbar(cax = celsius.make_colorbar_cax(), ticks=cmticks, **kwargs).set_label(label)
        plt.sca(old_ax)
Exemple #19
0
    def plot_frequency_altitude(self, f=2.0, ax=None, median_filter=False,
        vmin=None, vmax=None, altitude_range=(-99.9, 399.9), colorbar=False, return_image=False, annotate=True):

        if vmin is None:
            vmin = self.vmin

        if vmax is None:
            vmax = self.vmax

        if ax is None:
            ax = plt.gca()

        plt.sca(ax)
        plt.cla()
        freq_extent = (self.extent[0], self.extent[1],
            altitude_range[1], altitude_range[0])

        i = self.ionogram_list[0]
        inx = 1.0E6* (i.frequencies.shape[0] * f) / (i.frequencies[-1] - i.frequencies[0])
        img = self.tser_arr_all[:,int(inx),:]

        new_altitudes = np.arange(altitude_range[0], altitude_range[1], 14.)
        new_img = np.zeros((new_altitudes.shape[0], img.shape[1])) + np.nan

        for i in self.ionogram_list:
            e = int( round((i.time - self.extent[0]) / ais_code.ais_spacing_seconds ))

            pos = mex.iau_r_lat_lon_position(float(i.time))
            altitudes = pos[0] - ais_code.speed_of_light_kms * ais_code.ais_delays * 0.5 - mex.mars_mean_radius_km
            s = np.argsort(altitudes)
            new_img[:, e] = np.interp(new_altitudes, altitudes[s], img[s,e], left=np.nan, right=np.nan)

        plt.imshow(new_img, vmin=vmin, vmax=vmax,
            interpolation='Nearest', extent=freq_extent, origin='upper', aspect='auto')

        plt.xlim(freq_extent[0], freq_extent[1])
        plt.ylim(*altitude_range)

        ax.set_xlim(self.extent[0], self.extent[1])
        ax.xaxis.set_major_locator(celsius.SpiceetLocator())

        celsius.ylabel(r'Alt./km')
        if annotate:
            plt.annotate('f = %.1f MHz' % f, (0.02, 0.9),
                    xycoords='axes fraction', color='cyan', verticalalignment='top', fontsize='small')

        if colorbar:
            old_ax = plt.gca()
            plt.colorbar(cax = celsius.make_colorbar_cax(), ticks=self.cbar_ticks).set_label(r"$Log_{10} V^2 m^{-2} Hz^{-1}$")
            plt.sca(old_ax)

        if return_image:
            return new_img, freq_extent, new_altitudes
Exemple #20
0
 def plot_lon(self, ax=None, label=True, fmt='k-', **kwargs):
     if ax is None:
         ax = plt.gca()
     plt.sca(ax)
     self.make_axis_circular(ax)
     self.generate_position()
     v = celsius.deg_unwrap(self.iau_pos[2])
     for i in [-1,0,1]:
         plt.plot(self.t, v + i * 360, fmt, **kwargs)
     if label:
         celsius.ylabel(r'$\varphi$')
     plt.ylim(0., 360.)
Exemple #21
0
def plot_frame(dfplot,df,**kwargs):
    """
    Plot DataFrame
    
    Helper function for panels.
    """
    for i in dfplot.index:
        x = dfplot.ix[i]
        plt.sca(x['ax'])
        plt.plot(df[x['xk']],df[x['yk']],**kwargs)
        plt.xlabel(x['xL'])
        plt.ylabel(x['yL'])
def violin_plot(ax, values_list, measure_name, group_names, fontsize, color='blue',  ttest=False):
    '''
    This is a little wrapper around the statsmodels violinplot code
    so that it looks nice :)    
    '''    
    
    # IMPORTS
    import matplotlib.pylab as plt
    import statsmodels.api as sm
    import numpy as np
    
    # Make your violin plot from the values_list
    # Don't show the box plot because it looks a mess to be honest
    # we're going to overlay a boxplot on top afterwards
    plt.sca(ax)
    
    # Adjust the font size
    font = { 'size'   : fontsize}
    plt.rc('font', **font)

    max_value = np.max(np.concatenate(values_list))
    min_value = np.min(np.concatenate(values_list))
    
    vp = sm.graphics.violinplot(values_list,
                            ax = ax,
                            labels = group_names,
                            show_boxplot=False,
                            plot_opts = { 'violin_fc':color ,
                                          'cutoff': True,
                                          'cutoff_val': max_value,
                                          'cutoff_type': 'abs'})
    
    # Now plot the boxplot on top
    bp = plt.boxplot(values_list, sym='x')
    
    for key in bp.keys():
        plt.setp(bp[key], color='black', lw=fontsize/10)
        
    # Adjust the power limits so that you use scientific notation on the y axis
    plt.ticklabel_format(style='sci', axis='y')
    ax.yaxis.major.formatter.set_powerlimits((-3,3))
    plt.tick_params(axis='both', which='major', labelsize=fontsize)

    # Add the y label
    plt.ylabel(measure_name, fontsize=fontsize)
    
    # And now turn off the major ticks on the y-axis
    for t in ax.yaxis.get_major_ticks(): 
        t.tick1On = False 
        t.tick2On = False

    return ax
Exemple #23
0
    def plot_ne(self, fmt='k.', ax=None, errors=True, label=True,
        marsis=True, aspera=False, full_marsis=False, **kwargs):
        if ax is None:
            ax = plt.gca()
        plt.sca(ax)

        def parse_error(d):
            if not np.isfinite(d.fp_local):
                return
            f = ais_code.fp_to_ne(d.fp_local)
            f0 = ais_code.fp_to_ne(d.fp_local + d.fp_local_error)
            f1 = ais_code.fp_to_ne(d.fp_local - d.fp_local_error)
            if errors:
                plt.plot((d.time, d.time),(f0,f1),
                    color='lightgrey', linestyle='solid',
                    marker='None', zorder=-1000,**kwargs)
            plt.plot(d.time, f, fmt, ms=self.marker_size, zorder=1000, **kwargs)

            if full_marsis and hasattr(d, 'maximum_fp_local'):
                plt.plot(d.time, ais_code.fp_to_ne(d.maximum_fp_local),
                    'b.', ms=self.marker_size, zorder=900, **kwargs)

            if full_marsis:
                if np.isfinite(d.morphology_fp_local):
                    v, e = ais_code.fp_to_ne(d.morphology_fp_local,
                                                d.morphology_fp_local_error)
                    plt.errorbar(float(d.time), v, yerr=e,
                            marker='x', ms=1.3, color='purple',
                            zorder=1e90, capsize=0., ecolor='plum')

                if np.isfinite(d.integrated_fp_local):
                    v, e = ais_code.fp_to_ne(d.integrated_fp_local,
                                                d.integrated_fp_local_error)
                    plt.errorbar(float(d.time), v, yerr=e,
                            marker='x', ms=1.3, color='blue',
                            zorder=1e99, capsize=0., ecolor='cyan')

            # if hasattr(d, 'fp_local_length'):
            #     if d.fp_local_length > 40.:
            #         plt.scatter(d.time, f, s=(float(d.fp_local_length)/80. *)**2. * 5., color='k')
            # plt.errorbar(d.time, f, df, fmt='k', marker='None')

        list(map(parse_error, self.digitization_list))
        print("FP_LOCAL: %d" % len(
                    [d for d in self.digitization_list if np.isfinite(d.fp_local)]))

        ax.set_yscale('log')
        plt.ylim(11., 1.1E5)

        if label:
            # celsius.ylabel(r'$\mathrm{n_e / cm^{-3}}$')
            plt.ylabel(r'n$_e$ / cm$^{-3}$')
Exemple #24
0
    def plotres(d):
        plt.sca(d['ax'])
        x = smpar[d['xk']]
        y = smpar[d['yk']]
        tkw = dict(ha='center',va='center')
        plt.plot([x],[y],'oc',ms=15,mew=0)
        plt.text(x,y,'SM',**tkw)

        if libpar is not None:
            x = libpar[d['xk']]
            y = libpar[d['yk']]
            plt.plot([x],[y],'oc',ms=15,mew=0)
            plt.text(x,y,'LIB',**tkw)
Exemple #25
0
    def plot_ground_deltat(self, ax=None):
        if ax is None:
            ax = plt.gca()
        plt.sca(ax)
        t = [d.time for d in self.digitization_list if np.isfinite(d.ground)]
        d = [d.ground for d in self.digitization_list if np.isfinite(d.ground)]
        dnew = []
        for time, delay in zip(t, d):
            mex_pos = mex.iau_mars_position(float(time))
            alt = np.sqrt(np.sum(mex_pos * mex_pos)) - mex.mars_mean_radius_km
            dnew.append( (delay - alt * 2. / ais_code.speed_of_light_kms) * 1.0E3)
        plt.plot(t, dnew)

        celsius.ylabel(r'$\Delta\tau_D$ / ms')
Exemple #26
0
def chisq(df, fig=None, columns=['teff','logg','fe'], **kwargs):
    """Make a multi-panel plot of chisq
    """
    ncols = len(columns)
    if fig is None:
        fig,axL = plt.subplots(ncols=ncols)
    else:
        axL = fig.get_axes()

    i = 0
    for col in columns:
        plt.sca(axL[i])
        plt.semilogy()
        plt.plot(df[col],df['chisq'],**kwargs)
        i+=1
Exemple #27
0
def hcolorbar(*args, **kwargs):
    '''Arguments, label='', nticks=[3], cticks=[None], axes=[[0.8,0.01,0.1,0.02]] #[left,bottom, width,height], cax=[None] colorbar axis
    returns colorbar'''
    try:
        itemlabel = args[0].get_label()
        if itemlabel.startswith('_'):
            itemlabel = ''
    except:
        itemlabel = ''
    
    label = kwargs.pop('label', itemlabel)
    nticks = kwargs.pop('nticks', 3)
    cticks = kwargs.pop('cticks', None)
    cticknames = kwargs.pop('cticknames', None)
    rotate = kwargs.pop('rotate', None)
    
    tickfmt = kwargs.pop('tickfmt', None)
    axes = kwargs.pop('axes', [0.8,0.01,0.1,0.02])
    ax = pylab.gca()
    
    tmp = dict(
        # cax = pylab.axes(axes),
        orientation='horizontal',
    )
    tmp.update(kwargs)
    if 'cax' not in tmp:
        tmp['cax'] = pylab.axes(axes)
    
    cb = pylab.colorbar(*args, **tmp)
    cb.set_label(label)
    
    if cticks is None:
        cticks = np.linspace(cb.vmin, cb.vmax, nticks)
    cb.set_ticks(cticks)
    
    if tickfmt is not None:
        tmp = map(tickfmt.format, cticks)
        cb.set_ticklabels(tmp)
    
    if cticknames is not None:
        cb.set_ticklabels(cticknames)
    
    if rotate is not None:
        pylab.setp(pylab.xticks(axes=cb.ax)[1], rotation=90, ha='center')
        
    
    pylab.sca(ax)
    return cb
Exemple #28
0
def setup_lat_lon_ax(ax=None, label=True, tickspacing=30.0):
    if ax is None:
        ax = plt.gca()
    else:
        plt.sca(ax)

    plt.xlim(-180, 180)
    plt.xticks(np.arange(-360.0 - 180, 360.0 + 180 + 1.0, tickspacing))
    plt.ylim(-90, 90)
    plt.yticks(np.arange(-90, 90 + 1.0, tickspacing))

    if label:
        plt.xlabel("Lon. / deg")
        plt.ylabel("Lat. / deg")

    ax.set_aspect("equal")
Exemple #29
0
    def plot_frequency_range(self, f_min=0., f_max=0.2, ax=None, median=False,
        vmin=None, vmax=None, colorbar=False, max_value=False):

        if vmin is None:
            vmin = self.vmin

        if vmax is None:
            vmax = self.vmax

        if ax is None:
            ax = plt.gca()

        plt.sca(ax)
        plt.cla()
        freq_extent = (self.extent[0], self.extent[1],
            ais_code.ais_max_delay*1E3, ais_code.ais_min_delay*1E3)

        i = self.ionogram_list[0]
        inx, = np.where((i.frequencies > f_min*1E6) & (i.frequencies < f_max*1E6))

        if inx.shape[0] < 2:
            raise ValueError("Only %d frequency bins selected." % inx.shape[0])
        print("Averaging over %d frequency bins" % inx.shape[0])

        if median:
            if inx.shape[0] < 3:
                raise ValueError("Median here only really makes sense for 3 or more bins")
            img = np.median(self.tser_arr_all[:,inx,:],1)
        elif max_value:
            img = np.max(self.tser_arr_all[:,inx,:],1)
        else:
            img = np.mean(self.tser_arr_all[:,inx,:],1)
        plt.imshow(img, vmin=vmin, vmax=vmax,
            interpolation='Nearest', extent=freq_extent, origin='upper',aspect='auto')

        plt.xlim(freq_extent[0], freq_extent[1])
        plt.ylim(freq_extent[2], freq_extent[3])
        # plt.vlines(i.time,freq_extent[2],freq_extent[3], 'r')
        celsius.ylabel(r'$\tau_D / ms$' '\n' '%.1f-%.1f MHz' % (f_min, f_max))
        # plt.annotate('f = %.1f - %.1f MHz' % (f_min, f_max), (0.02, 0.9), xycoords='axes fraction',
            # color='grey', verticalalignment='top', fontsize='small')

        if colorbar:
            old_ax = plt.gca()
            plt.colorbar(cax = celsius.make_colorbar_cax(), ticks=self.cbar_ticks).set_label(r"$Log_{10} V^2 m^{-2} Hz^{-1}$")
            plt.sca(old_ax)
Exemple #30
0
def make_colorbar_cax(ax=None, width=0.01, offset=0.02, height=0.9,
                        left=False, half=False, upper=True):
    """Define a new vertical colorbar axis relative to :ax:.  Avoids 'stealing' space from the axis, required for stack plots.

Args:
    ax: Axes instance to work with, defaults to current.
    width: width of colorbar relative to axes width
    height: height relative to axes height
    offset: offset relative to appropriate axes dimension
    left: place on left side (default False)
    half: only occupy half the vertical extent, for two colorbars?
    upper: upper of two colorbars?

Returns:
    new axes instance for passing to colorbar(cax=...)
"""
    if ax is None:
        ax = plt.gca()
    else:
        plt.sca(ax)

    bbox = ax.get_position()
    x0 = bbox.x1
    if left:
        offset = abs(offset) * -1.0
        x0 = bbox.x0

    y0 = bbox.y0
    y1 = bbox.y1
    # ys = (1.0 - height) * (y1 - y0)
    ys = (1.0 - height) * (y1 - y0) / 2.
    # new_ax_coords = [x0 + offset, y0 + ys, width, height * (y1 - y0) - ys]
    new_ax_coords = [x0 + offset, y0 + ys, width, height * (y1 - y0)]

    # |==|---------|==|----------|==|
    if half:
        new_ax_coords[3] = new_ax_coords[3] / 2.
        if upper:
            new_ax_coords[1] = y0 + height * (y1 - y0) * 0.5 + ys/2.
        else:
            new_ax_coords[1] -= ys/2.
    new_ax = ax.figure.add_axes(new_ax_coords)
    plt.sca(ax)
    return new_ax
Exemple #31
0
                y_sel = (z >= elev_min) & (z < elev_max) & (x_sel)
            else:
                y_sel = (z >= elev_min) & (x_sel)

            sel_nodes = np.where(y_sel)[0]

            H[i, j] = int(len(sel_nodes))
            #sel_nodes = grid.core_nodes
            if len(sel_nodes) > 0:
                cat[sel_nodes] = val
                cat_bin[sel_nodes] = len(sel_nodes)
                cat_plot[sel_nodes] = cat[sel_nodes]
                val += 1

        cat_plot[cat_plot == 0] = cat_plot[cat_plot > 0].min() - 1
        plt.sca(axarr[i])
        imshow_grid(grid, cat_plot, cmap='viridis')
        plt.axis('off')

    plt.savefig(site + '.cats.png')

    plt.figure(figsize=(4, 3), dpi=300)
    imshow_grid(grid, cat, cmap='tab20',
                limits=(0.5, 20.5))  #, plot_name='Chi-Elevation Category')
    plt.axis('off')
    plt.savefig(site + '.all_cats.png')

    plt.figure(dpi=300)
    imshow_grid(grid,
                cat_bin,
                cmap='inferno',
statement = statement.replace('AW', str(np.around(aw, 2)))
statement = statement.replace('WA', str(np.around(wa, 2)))
statement = statement.replace('AA', str(np.around(aa, 2)))

print(statement)

cmap = sns.diverging_palette(220, 10, as_cmap=True)
names = [
    'white_m', 'api_m', 'hispanic_m', 'black_m', 'white_w', 'api_w',
    'hispanic_w', 'black_w'
]
plt.close()
sns.set(style='white', font=font)
fig, axes = plt.subplots(ncols=2, nrows=1, figsize=(7.5, 4))
axes = axes.flatten()
plt.sca(axes[0])
heat = sns.heatmap(np.around((citation_matrix / citation_matrix.sum()) * 100,
                             2),
                   annot=True,
                   ax=axes[0],
                   annot_kws={"size": 8},
                   cmap=cmap,
                   vmax=1,
                   vmin=0)
axes[0].set_ylabel('first author', labelpad=0)
heat.set_yticklabels(names, rotation=0)
axes[0].set_xlabel('last author', labelpad=1)
heat.set_xticklabels(names, rotation=90)
heat.set_title('percentage of citations')

citation_matrix_sum = citation_matrix / np.sum(citation_matrix)
def train_model(network):
    adam = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
    network.compile(loss='categorical_crossentropy',
                    optimizer=adam,
                    metrics=['accuracy'])
    network.summary()
    plot_model(network, to_file=graph_path)

    batch_num = 0
    model_save_acc = 0
    all_train_accuracy = []
    all_train_loss = []
    all_tst_accuracy = []

    tst_data = DataGenerator(h5file_path=tst_path,
                             batch_size=batch_size,
                             frames=frames)
    tst_data_name = tst_data.get_data_name()
    tst_cursors = [tst_data.get_cursors(name) for name in tst_data_name]

    for epoch in range(epochs):
        accuracy_list = []
        loss_list = []
        print(epoch + 1, ' epoch is beginning......')
        train_data = DataGenerator(h5file_path=train_path,
                                   batch_size=batch_size,
                                   frames=frames)
        train_data_name = train_data.get_data_name()
        train_data_cursors = train_data.batch_cursors(len(train_data_name))
        index_num = random.sample(range(len(train_data_cursors)),
                                  len(train_data_cursors))

        for ind in index_num:
            batch_num += 1
            up_data_0, down_data_0, train_labels_0 \
                = train_data.generate_batch_data(train_data_name, train_data_cursors[ind], 0)
            up_data_1, down_data_1, train_labels_1 \
                = train_data.generate_batch_data(train_data_name, train_data_cursors[ind], 1)
            train_loss = network.train_on_batch(
                [up_data_0, up_data_1, down_data_0, down_data_1],
                train_labels_0)
            accuracy_list.append(train_loss[1])
            loss_list.append(train_loss[0])
            if batch_num % 50 == 0:
                print('the %r batch: loss: %r  accuracy: %r' %
                      (batch_num, train_loss[0], train_loss[1]))

        epoch_accuracy = sum(accuracy_list) / len(accuracy_list)
        epoch_loss = sum(loss_list) / len(loss_list)
        all_train_accuracy.append(epoch_accuracy)
        all_train_loss.append(epoch_loss)

        print('the %r epoch: mean loss: %r    mean accuracy: %r' %
              (epoch + 1, epoch_loss, epoch_accuracy))

        if epoch >= 0:
            tst_accuracy_list = []
            for num in range(len(tst_data_name)):
                tst_up_0, tst_down_0, tst_labels_0 = \
                    tst_data.get_tst_single_data(tst_data_name[num], tst_cursors[num], 0)
                tst_up_1, tst_down_1, tst_labels_1 = \
                    tst_data.get_tst_single_data(tst_data_name[num], tst_cursors[num], 1)
                tst_loss = network.test_on_batch(
                    [tst_up_0, tst_up_1, tst_down_0, tst_down_1], tst_labels_0)
                tst_accuracy_list.append(tst_loss[1])
            tst_accuracy = sum(tst_accuracy_list) / len(tst_accuracy_list)
            all_tst_accuracy.append(tst_accuracy)
            print('The test data accuracy: %r' % tst_accuracy)
            if tst_accuracy > model_save_acc:
                network.save_weights(weight_path)
                model_save_acc = tst_accuracy

    pl.figure()
    trn_acc = pl.subplot(2, 2, 1)
    trn_loss = pl.subplot(2, 2, 2)
    tst_acc = pl.subplot(2, 1, 2)

    pl.sca(trn_acc)
    pl.plot(range(len(all_train_accuracy)),
            all_train_accuracy,
            label='train accuracy')
    pl.xlabel('Epoch')
    pl.ylabel('Accuracy')
    pl.ylim(0, 1.0)

    pl.sca(trn_loss)
    pl.plot(range(len(all_train_loss)), all_train_loss, label='loss')
    pl.xlabel('Epoch')
    pl.ylabel('Loss')
    pl.ylim(0, 5.0)

    pl.sca(tst_acc)
    pl.plot(range(len(all_tst_accuracy)),
            all_tst_accuracy,
            label='test accuracy')
    pl.xlabel('Epoch')
    pl.ylabel('Accuracy')
    pl.ylim(0, 1.0)

    pl.legend()
    pl.show()
                self.c.canopy.flux_to(self.c.evaporation, t),
                self.c.surfacewater.flux_to(self.c.evaporation, t),
                self.c.layers[0].flux_to(self.c.evaporation, t),
                self.c.layers[0].flux_to(self.c.transpiration, t),
                self.c.surfacewater.flux_to(self.c.layers[0], t),
            ))
            resistance.append((self.et.RAA, self.et.RAC, self.et.RAS,
                               self.et.RSC, self.et.RSS))
            mpot.append(self.c.surface_water_coverage())
        return vol, flux, resistance, mpot


if __name__ == '__main__':
    print(cmf.__version__)
    m = Model()
    vol, flux, resistance, mpot = m(10)
    from matplotlib import pylab as plt
    fig, ax = plt.subplots(3, 1, sharex='all')
    plt.sca(ax[0])
    plt.plot(vol)
    plt.legend(['Canopy', 'Surfacewater', 'Layer'], loc=0)
    plt.sca(ax[1])
    plt.plot(flux)
    plt.legend(
        ['E_Canopy', 'E_Surfacewater', 'E_Layer', 'T_Layer', 'Infiltration'],
        loc=0)
    plt.sca(ax[2])
    plt.plot(resistance)
    plt.legend('RAA RAC RAS RSC RSS'.split(), loc=0)
    plt.show()
Exemple #35
0
    frl3NonVoida = (np.shape(np.where(np.abs(l3_nonVoid) <= i)[0])[0] /
                    (1. * size_fact**3)) * L

    frl1NonVoid = np.append(frl1NonVoid, frl1NonVoida)
    frl2NonVoid = np.append(frl2NonVoid, frl2NonVoida)
    frl3NonVoid = np.append(frl3NonVoid, frl3NonVoida)

#f, axarr = plt.subplots(2, sharex=True)
#axarr[0].plot(x, y)
#axarr[0].set_title('Sharing X axis')
#axarr[1].scatter(x, y)

#plt.figure(5)
f, axarr = plt.subplots(2, figsize=(8, 12), sharex=True)
f.subplots_adjust(hspace=0.02)
plt.sca(axarr[0])
axarr[0].plot(cutfr, frl1, '--', lw=1.5, label=r"$\lambda_1$")
axarr[0].plot(cutfr, frl2, '--', lw=1.5, label=r"$\lambda_2$")
axarr[0].plot(cutfr, frl3, '--', lw=1.5, label=r"$\lambda_3$")
plt.xscale('log')
#plt.xlim(np.min(cutfr), 4)
#plt.ylim(9,95)
#plt.yticks( [0.1, 0.5, 0.9] )
axarr[0].legend(loc="upper left")
plt.ylabel(" Volume fraction of $|\lambda| < \lambda_{th}$ ")
plt.minorticks_on()

#plt.xlabel(r" $ \lambda_{th} $")

#plt.subplot(2,1,2)
plt.sca(axarr[1])