Ejemplo n.º 1
0
 def __call__(self, value, clip=None):
     if clip is None:
         clip = self.clip
     if cbook.iterable(value):
         vtype = 'array'
         val = ma.asarray(value).astype(np.float)
     else:
         vtype = 'scalar'
         val = ma.array([value]).astype(np.float)
     self.autoscale_None(val)
     vmin, vmax = self.vmin, self.vmax
     cmin, cmax = self.cmin * vmin, self.cmax * vmax
     if vmin > vmax:
         raise ValueError("minvalue must be less than or equal to maxvalue")
     elif vmin == vmax:
         result = 0.0 * val
     else:
         if clip:
             mask = ma.getmask(val)
             val = ma.array(np.clip(val.filled(vmax), vmin, vmax),
                             mask=mask)
         result = 0. * val + 0.5
         result[val > cmax] = (ma.log10(val[val > cmax]) - ma.log10(cmax)) / (np.log10(vmax) - np.log10(cmax)) / 2. + 0.5
         result[val < cmin] = -(ma.log10(-val[val < cmin]) - ma.log10(-cmin)) / (np.log10(-vmin) - np.log10(-cmin)) / 2. + 0.5
     if vtype == 'scalar':
         result = result[0]
     return result
Ejemplo n.º 2
0
def make_qq_plot(qq, ci=True, ylim=7.3, xlim=7.3):
    hv_logp = np.array(qq['hv_logp']).astype(float)
    data_logpvec = np.array(qq['data_logpvec']).astype(float)
    model_logpvec = np.array(qq['model_logpvec']).astype(float)
    ylim_data = max(hv_logp[np.isfinite(data_logpvec)])
    model_logpvec[hv_logp > ylim_data] = np.nan
    if ci:
        q = 10**-data_logpvec
        dq = 1.96 * np.sqrt(q * (1 - q) / qq['sum_data_weights'])
        y1 = hv_logp
        x1 = ma.filled(-ma.log10(q + dq), np.nan)  #left CI bound
        x2 = ma.filled(-ma.log10(q - dq), np.nan)  #right CI bound
        if True:
            y2 = np.empty(hv_logp.shape)
            y2[:] = np.nan
            y2[x2 < np.nanmax(x1)] = interp1d(x1, y1)(
                x2[x2 < np.nanmax(x1)])  #upper CI bound
            y2[np.isnan(y2)] = ylim_data
            plt.fill_between(x2,
                             y1,
                             y2,
                             color=(0.1843, 0.3098, 0.3098),
                             alpha=0.25)
        else:
            plt.plot(x1, hv_logp, x2, hv_logp)
    hData = plt.plot(data_logpvec, hv_logp)
    hModel = plt.plot(model_logpvec, hv_logp)
    hNull = plt.plot(hv_logp, hv_logp, 'k--')
    plt.ylim(0, ylim)
    plt.xlim(0, xlim)
Ejemplo n.º 3
0
def components(prof, p):
    '''
    Interpolates the given data to calculate the U and V components at a
    given pressure

    Parameters
    ----------
    prof : profile object
        Profile object
    p : number, numpy array
        Pressure (hPa) of a level

    Returns
    -------
    U and V components at the given pressure (kts) : number, numpy array
    '''
    # Note: numpy's interpolation routine expects the interpolation
    # routine to be in ascending order. Because pressure decreases in the
    # vertical, we must reverse the order of the two arrays to satisfy
    # this requirement.
    if prof.wdir.count() == 0:
        # JTS - Fixed a bug where clicking "Interpolate Focused Profile" throws an error for NUCAPS.
        return ma.masked_where(ma.ones(np.shape(p)),
                               p), ma.masked_where(ma.ones(np.shape(p)), p)
    U = generic_interp_pres(ma.log10(p), prof.logp[::-1], prof.u[::-1])
    V = generic_interp_pres(ma.log10(p), prof.logp[::-1], prof.v[::-1])
    return U, V
Ejemplo n.º 4
0
def degree_distribution(A, networkName, directed=True):
    binNum = 30

    if (directed):
        (kin, kout) = get_degree(A)
        bins = np.linspace(0, np.log10(np.max(kin)), num=binNum)
        digitized = np.digitize(np.log10(kin), bins)
        bin_counts = np.asarray([digitized.tolist().count(i) for i in range(0,len(bins))])
        bin_counts = ma.log10(bin_counts)
        #fit the line
        a,b = ma.polyfit(bins, bin_counts, 1, full=False)
        print('best fit in degree line:\ny = {:.2f} + {:.2f}x'.format(b, a))
        yfit = [b + a * xi for xi in bins]
        fig, axs = plt.subplots(2, 1)
        axs[0].scatter(bins, bin_counts)
        axs[0].plot(bins, yfit, color="orange")
        axs[0].set_title('in-degree distribution')
        axs[0].set_xlabel('Degree (d) log base 10', fontsize="small")
        axs[0].set_ylabel('Frequency log base 10', fontsize="small")
        axs[0].set_ylim(bottom=0)

        bins = np.linspace(0, np.log10(np.max(kout)), num=binNum)
        digitized = np.digitize(np.log10(kout), bins)
        bin_counts = np.asarray([digitized.tolist().count(i) for i in range(0,len(bins))])
        bin_counts = ma.log10(bin_counts)
        print('best fit out degree line:\ny = {:.2f} + {:.2f}x'.format(b, a))
        yfit = [b + a * xi for xi in bins]
        axs[1].scatter(bins, bin_counts)
        axs[1].plot(bins, yfit, color="orange")
        axs[1].set_title('out-degree distribution')
        axs[1].set_xlabel('Degree (d) log base 10', fontsize="small")
        axs[1].set_ylabel('Frequency log base 10', fontsize="small")
        plt.subplots_adjust(hspace=0.01)
        plt.tight_layout()
        plt.savefig(networkName + 'degree.pdf')
        plt.close()

    if (not directed):
        (kin,kout) = get_degree(A)
        print (kin.shape)
        #bin the statistics
        bins = np.linspace(0, np.log10(np.max(kin)), num=binNum)
        digitized = np.digitize(np.log10(kin), bins)
        bin_counts = np.asarray([digitized.tolist().count(i) for i in range(0,len(bins))])
        bin_counts = ma.log10(bin_counts)
        #fit the line
        a,b = ma.polyfit(bins, bin_counts, 1, full=False)
        print('best fit line:\ny = {:.2f} + {:.2f}x'.format(b, a))
        yfit = [b + a * xi for xi in bins]
        plt.scatter(bins, bin_counts)
        plt.plot(bins, yfit, color="orange")
        plt.title('degree distribution')
        plt.xlabel('Degree (d) log base 10', fontsize="small")
        plt.ylabel('Frequency log base 10', fontsize="small")
        plt.ylim(bottom=0)
        # plt.xscale('log')
        # plt.yscale('log')
        plt.tight_layout()
        plt.savefig(networkName + 'degree.pdf')
        plt.close()
Ejemplo n.º 5
0
def components(prof, p):
    '''
    Interpolates the given data to calculate the U and V components at a
    given pressure

    Parameters
    ----------
    prof : profile object
        Profile object
    p : number, numpy array
        Pressure (hPa) of a level

    Returns
    -------
    U and V components at the given pressure (kts) : number, numpy array
    '''
    # Note: numpy's interpoloation routine expects the interpoloation
    # routine to be in ascending order. Because pressure decreases in the
    # vertical, we must reverse the order of the two arrays to satisfy
    # this requirement.
    if prof.wdir.count() == 0:
        return ma.masked, ma.masked
    U = generic_interp_pres(ma.log10(p), prof.logp[::-1], prof.u[::-1])
    V = generic_interp_pres(ma.log10(p), prof.logp[::-1], prof.v[::-1])
    return U, V
Ejemplo n.º 6
0
    def plot(self,
             ax=None,
             fig=None,
             xlim=(-1.5, .5),
             ylim=(-1.2, 1.5),
             **kwargs):

        if fig is None and ax is None:
            fig = plt.figure(1, figsize=(6, 6))

        if ax is None:
            ax = fig.add_subplot(111)

        self.ax = ax

        ax.set_xlabel(r'$\log_{10}$ [N II]/H$\alpha$')
        ax.set_ylabel(r'$\log_{10}$ [O III]/H$\beta$')

        ax.set_xlim(*xlim)
        ax.set_ylim(*ylim)

        self.x = ma.log10(self.n2 / self.ha)
        self.y = ma.log10(self.o3 / self.hb)

        ax.scatter(self.x, self.y, **kwargs)

        self.kauffmann2003()

        return
Ejemplo n.º 7
0
    def __init__(self, wha, flux_ha, flux_n2):

        for line in ('wha', 'flux_ha', 'flux_n2'):
            if not isinstance(eval(line), ma.masked_array):
                self.__dict__.update({line: ma.masked_array(eval(line))})
            else:
                self.__dict__[line] = eval(line)

        self.x = ma.log10(self.flux_n2 / self.flux_ha)
        self.y = ma.log10(self.wha)
Ejemplo n.º 8
0
def plot_cov():
    # see http://stackoverflow.com/questions/13784201/matplotlib-2-subplots-1-colorbar
    fig, axes = plt.subplots(
        nrows=2, ncols=2, figsize=(14, 14),
        sharex=True, sharey=True)

    imshow_kwargs = {
        'cmap': 'Purples',
        'origin': 'upper',
        'interpolation': 'none',
        'vmin': -13,
        'vmax': -7
    }

    s = slice(None, None)

    I, J, V = cov_dr11_raw.T
    cov = sparse.coo_matrix((V, (I, J)), shape=(N, N)).tocsr().toarray()
    print('min(cov): {}'.format(np.min(cov)))
    print('max(cov): {}'.format(np.max(cov)))

    ax = axes[0, 0]
    im = ax.imshow(ma.log10(cov[s, s]), **imshow_kwargs)
    ax.tick_params(direction='in')
    ax.set_ylabel('log(+C)', fontsize=18)
    # fig.colorbar(im, ax=ax)

    ax = axes[1, 0]
    im = ax.imshow(ma.log10(-cov[s, s]), **imshow_kwargs)
    ax.tick_params(direction='in')
    ax.set_ylabel('log(-C)', fontsize=18)
    ax.set_xlabel('DR11', fontsize=18)
    # fig.colorbar(im, ax=ax)

    # I, J, V = cov_mock000_raw.T
    # cov = sparse.coo_matrix((V, (I, J)), shape=(N, N)).tocsr().toarray()
    cov = np.tril(smo_cov)
    print('min(cov): {}'.format(np.min(cov)))
    print('max(cov): {}'.format(np.max(cov)))

    ax = axes[0, 1]
    im = ax.imshow(ma.log10(cov[s, s]), **imshow_kwargs)
    ax.tick_params(direction='in')
    # fig.colorbar(im, ax=ax)

    ax = axes[1, 1]
    im = ax.imshow(ma.log10(-cov[s, s]), **imshow_kwargs)
    ax.tick_params(direction='in')
    ax.set_xlabel('DM', fontsize=18)
    # fig.colorbar(im, ax=ax)

    plt.tight_layout()
Ejemplo n.º 9
0
    def __call__(self, value, clip=None):

        method = self.stretch
        exponent = self.exponent
        midpoint = self.midpoint

        if clip is None:
            clip = self.clip

        if cbook.iterable(value):
            vtype = 'array'
            val = ma.asarray(value).astype(np.float)
        else:
            vtype = 'scalar'
            val = ma.array([value]).astype(np.float)

        self.autoscale_None(val)
        vmin, vmax = self.vmin, self.vmax
        if vmin > vmax:
            raise ValueError("minvalue must be less than or equal to maxvalue")
        elif vmin == vmax:
            return 0.0 * val
        else:
            if clip:
                mask = ma.getmask(val)
                val = ma.array(np.clip(val.filled(vmax), vmin, vmax),
                               mask=mask)
            result = (val - vmin) * (1.0 / (vmax - vmin))

            negative = result < 0.
            if self.stretch == 'linear':
                pass
            elif self.stretch == 'log':
                result = ma.log10(result * (self.midpoint - 1.) + 1.) \
                       / ma.log10(self.midpoint)
            elif self.stretch == 'sqrt':
                result = ma.sqrt(result)
            elif self.stretch == 'arcsinh':
                result = ma.arcsinh(result / self.midpoint) \
                       / ma.arcsinh(1. / self.midpoint)
            elif self.stretch == 'power':
                result = ma.power(result, exponent)
            else:
                raise Exception("Unknown stretch in APLpyNormalize: %s" %
                                self.stretch)
            result[negative] = -np.inf

        if vtype == 'scalar':
            result = result[0]
        return result
Ejemplo n.º 10
0
 def test_testUfuncs1(self):
     # Test various functions such as sin, cos.
     (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
     assert_(eq(np.cos(x), cos(xm)))
     assert_(eq(np.cosh(x), cosh(xm)))
     assert_(eq(np.sin(x), sin(xm)))
     assert_(eq(np.sinh(x), sinh(xm)))
     assert_(eq(np.tan(x), tan(xm)))
     assert_(eq(np.tanh(x), tanh(xm)))
     with np.errstate(divide='ignore', invalid='ignore'):
         assert_(eq(np.sqrt(abs(x)), sqrt(xm)))
         assert_(eq(np.log(abs(x)), log(xm)))
         assert_(eq(np.log10(abs(x)), log10(xm)))
     assert_(eq(np.exp(x), exp(xm)))
     assert_(eq(np.arcsin(z), arcsin(zm)))
     assert_(eq(np.arccos(z), arccos(zm)))
     assert_(eq(np.arctan(z), arctan(zm)))
     assert_(eq(np.arctan2(x, y), arctan2(xm, ym)))
     assert_(eq(np.absolute(x), absolute(xm)))
     assert_(eq(np.equal(x, y), equal(xm, ym)))
     assert_(eq(np.not_equal(x, y), not_equal(xm, ym)))
     assert_(eq(np.less(x, y), less(xm, ym)))
     assert_(eq(np.greater(x, y), greater(xm, ym)))
     assert_(eq(np.less_equal(x, y), less_equal(xm, ym)))
     assert_(eq(np.greater_equal(x, y), greater_equal(xm, ym)))
     assert_(eq(np.conjugate(x), conjugate(xm)))
     assert_(eq(np.concatenate((x, y)), concatenate((xm, ym))))
     assert_(eq(np.concatenate((x, y)), concatenate((x, y))))
     assert_(eq(np.concatenate((x, y)), concatenate((xm, y))))
     assert_(eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))
Ejemplo n.º 11
0
 def test_testUfuncs1(self):
     # Test various functions such as sin, cos.
     (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
     assert_(eq(np.cos(x), cos(xm)))
     assert_(eq(np.cosh(x), cosh(xm)))
     assert_(eq(np.sin(x), sin(xm)))
     assert_(eq(np.sinh(x), sinh(xm)))
     assert_(eq(np.tan(x), tan(xm)))
     assert_(eq(np.tanh(x), tanh(xm)))
     with np.errstate(divide='ignore', invalid='ignore'):
         assert_(eq(np.sqrt(abs(x)), sqrt(xm)))
         assert_(eq(np.log(abs(x)), log(xm)))
         assert_(eq(np.log10(abs(x)), log10(xm)))
     assert_(eq(np.exp(x), exp(xm)))
     assert_(eq(np.arcsin(z), arcsin(zm)))
     assert_(eq(np.arccos(z), arccos(zm)))
     assert_(eq(np.arctan(z), arctan(zm)))
     assert_(eq(np.arctan2(x, y), arctan2(xm, ym)))
     assert_(eq(np.absolute(x), absolute(xm)))
     assert_(eq(np.equal(x, y), equal(xm, ym)))
     assert_(eq(np.not_equal(x, y), not_equal(xm, ym)))
     assert_(eq(np.less(x, y), less(xm, ym)))
     assert_(eq(np.greater(x, y), greater(xm, ym)))
     assert_(eq(np.less_equal(x, y), less_equal(xm, ym)))
     assert_(eq(np.greater_equal(x, y), greater_equal(xm, ym)))
     assert_(eq(np.conjugate(x), conjugate(xm)))
     assert_(eq(np.concatenate((x, y)), concatenate((xm, ym))))
     assert_(eq(np.concatenate((x, y)), concatenate((x, y))))
     assert_(eq(np.concatenate((x, y)), concatenate((xm, y))))
     assert_(eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))
Ejemplo n.º 12
0
    def inverse(self, value):

        if not self.scaled():
            raise ValueError("Not invertible until scaled")

        vmin, vmax = self.vmin, self.vmax

        if cbook.iterable(value):
            val = ma.asarray(value)
        else:
            val = value

        if self.stretch == 'linear':
            pass
        elif self.stretch == 'log':
            val = (ma.power(10., val * ma.log10(self.midpoint)) -
                   1.) / (self.midpoint - 1.)
        elif self.stretch == 'sqrt':
            val = val * val
        elif self.stretch == 'arcsinh':
            val = self.midpoint * \
                  ma.sinh(val * ma.arcsinh(1. / self.midpoint))
        elif self.stretch == 'power':
            val = ma.power(val, (1. / self.exponent))
        else:
            raise Exception("Unknown stretch in APLpyNormalize: %s" %
                            self.stretch)
        return vmin + val * (vmax - vmin)
Ejemplo n.º 13
0
def average_in_flux(mag, dmag, axis=None):
    flux = 10**(mag / -2.5)
    dflux = np.log(10) / 2.5 * flux * dmag
    avg_dflux = np.power(np.sum(np.power(dflux, -2), axis), -0.5)
    avg_flux = np.sum(flux * np.power(dflux, -2), axis) * avg_dflux**2
    avg_mag = -2.5 * np.log10(avg_flux)
    avg_dmag = 2.5 / np.log(10) * np.divide(avg_dflux, avg_flux)
    return avg_mag, avg_dmag
Ejemplo n.º 14
0
def average_in_flux(mag, dmag, axis=None):
    flux = 10**(mag / -2.5)
    dflux = np.log(10) / 2.5 * flux * dmag
    avg_dflux = np.power(np.sum(np.power(dflux, -2), axis), -0.5)
    avg_flux = np.sum(flux * np.power(dflux, -2), axis) * avg_dflux**2
    avg_mag = -2.5 * np.log10(avg_flux)
    avg_dmag = 2.5 / np.log(10) * np.divide(avg_dflux, avg_flux)
    return avg_mag, avg_dmag
Ejemplo n.º 15
0
        def transform_non_affine(self, a):
            oneminus = 1 - a
            oneminus[oneminus <= 0.0] = 1e-300

            thres = 1.0 - 10**(-self.nines - 1)
            mask = a > thres
            masked = ma.masked_where(mask, a)
            if masked.mask.any():
                return -ma.log10(oneminus)
            else:
                return -np.log10(oneminus)
Ejemplo n.º 16
0
    def inverse(self, value):

        # ORIGINAL MATPLOTLIB CODE

        if not self.scaled():
            raise ValueError("Not invertible until scaled")

        vmin, vmax = self.vmin, self.vmax

        # CUSTOM APLPY CODE

        if cbook.iterable(value):
            val = ma.asarray(value)
        else:
            val = value

        if self.stretch == 'Linear':

            pass

        elif self.stretch == 'Log':

            val = (ma.power(10., val * ma.log10(self.midpoint)) -
                   1.) / (self.midpoint - 1.)

        elif self.stretch == 'Sqrt':

            val = val * val

        elif self.stretch == 'Arcsinh':

            val = self.midpoint * \
                  ma.sinh(val * ma.arcsinh(1. / self.midpoint))

        elif self.stretch == 'Arccosh':

            val = self.midpoint * \
                  ma.cosh(val * ma.arccosh(1. / self.midpoint))

        elif self.stretch == 'Power':

            val = ma.power(val, (1. / self.exponent))

        elif self.stretch == 'Exp':

            val = 1. / np.exp(val)

        else:

            raise Exception("Unknown stretch in APLpyNormalize: %s" %
                            self.stretch)

        return vmin + val * (vmax - vmin)
Ejemplo n.º 17
0
def get_noise_levels(ncfile):

    # ----------------
    # Open NetCDF file
    # ----------------
    print('Opening NetCDF file ' + ncfile)
    dataset = nc4.Dataset(ncfile,'r+',format='NETCDF3_CLASSIC')

    nray    = len(dataset.dimensions['time']);
    ngate   = len(dataset.dimensions['range']);

    elv = np.transpose(np.tile(dataset.variables['elevation'][:],(ngate,1)));
    rng = np.tile(dataset.variables['range'][:],(nray,1))

    height = rng*np.sin(elv*np.pi/180.)

    zh = dataset.variables['ZED_H'][:];
    zed = ma.masked_where(height<14000, zh);

    rngkm = ma.masked_where(rng<=0.0, rng/1000.);

    range2 = 20.*ma.log10(rngkm);

    zh[:] = zed - range2;
    zv = zh.copy();
    zv[:] = zh[:] - dataset.variables['ZDR'][:]

    zx = zh.copy();
    zx[:] = zh[:] + dataset.variables['LDR'][:]

    nezharr = ma.mean(zh,axis=1)
    nezherr = ma.std(zh,axis=1)
    nezvarr = ma.mean(zv,axis=1)
    nezverr = ma.std(zv,axis=1)
    nezxarr = ma.mean(zx,axis=1)
    nezxerr = ma.std(zx,axis=1)

    nezharr = ma.masked_where(nezherr>MAX_ERR,nezharr)
    nezvarr = ma.masked_where(nezverr>MAX_ERR,nezvarr)
    nezxarr = ma.masked_where(nezxerr>MAX_ERR,nezxarr)

    nezh = ma.median(nezharr)
    nezv = ma.median(nezvarr)
    nezx = ma.median(nezxarr)

    dataset.close()


    return np.round(nezh,2), np.round(nezv,2), np.round(nezx,2)
Ejemplo n.º 18
0
    def inverse(self, value):

        # ORIGINAL MATPLOTLIB CODE

        if not self.scaled():
            raise ValueError("Not invertible until scaled")

        vmin, vmax = self.vmin, self.vmax

        # CUSTOM APLPY CODE

        if cbook.iterable(value):
            val = ma.asarray(value)
        else:
            val = value

        if self.stretch == 'linear':

            pass

        elif self.stretch == 'log':

            val = (ma.power(10., val * ma.log10(self.midpoint)) - 1.) / (self.midpoint - 1.)

        elif self.stretch == 'sqrt':

            val = val * val

        elif self.stretch == 'arcsinh':

            val = self.midpoint * \
                  ma.sinh(val * ma.arcsinh(1. / self.midpoint))

        elif self.stretch == 'square':

            val = ma.power(val, (1. / 2))

        elif self.stretch == 'power':

            val = ma.power(val, (1. / self.exponent))

        else:

            raise Exception("Unknown stretch in APLpyNormalize: %s" %
                            self.stretch)

        return vmin + val * (vmax - vmin)
Ejemplo n.º 19
0
 def transform_non_affine(self, a):
     """
     This transform takes an Nx1 ``numpy`` array and returns a
     transformed copy.  Since the range of the Mercator scale
     is limited by the user-specified threshold, the input
     array must be masked to contain only valid values.
     ``matplotlib`` will handle masked arrays and remove the
     out-of-range data from the plot.  Importantly, the
     ``transform`` method *must* return an array that is the
     same shape as the input array, since these values need to
     remain synchronized with values in the other dimension.
     """
     masked = ma.masked_where(((a - self.zero) * self.sign <= 0.0), (a - self.zero) * self.sign)
     if masked.mask.any():
         return ma.log10(masked) / np.log10 (self.base)
     else:
         return np.log10((a - self.zero) * self.sign) / np.log10 (self.base)
Ejemplo n.º 20
0
def vtmp(prof, p):
    '''
    Interpolates the given data to calculate a virtual temperature
    at a given pressure

    Parameters
    ----------
    prof : profile object
        Profile object
    p : number, numpy array
        Pressure (hPa) of the level for which virtual temperature is desired

    Returns
    -------
    Virtual tmperature (C) at the given pressure : number, numpy array

    '''
    return generic_interp_pres(ma.log10(p), prof.logp[::-1], prof.vtmp[::-1])
Ejemplo n.º 21
0
 def transform_non_affine(self, a):
     lower = a[np.where(a<=change)]
     greater = a[np.where(a> change)]
     if lower.size:
         lower = self._handle_nonpos(lower * 10.0)/10.0
         if isinstance(lower, ma.MaskedArray):
             lower = ma.log10(lower)
         else:
             lower = np.log10(lower)
         lower = factor*lower
     if greater.size:
         greater = (factor*np.log10(change) + (greater-change))
     # Only low
     if not(greater.size):
         return lower
     # Only high
     if not(lower.size):
         return greater
     return np.concatenate((lower, greater))
Ejemplo n.º 22
0
 def transform_non_affine(self, a):
     lower = a[np.where(a<=change)]
     greater = a[np.where(a> change)]
     if lower.size:
         lower = self._handle_nonpos(lower * 10.0)/10.0
         if isinstance(lower, ma.MaskedArray):
             lower = ma.log10(lower)
         else:
             lower = np.log10(lower)
         lower = factor*lower
     if greater.size:
         greater = (factor*np.log10(change) + (greater-change))
     # Only low
     if not(greater.size):
         return lower
     # Only high
     if not(lower.size):
         return greater
     return np.concatenate((lower, greater))
Ejemplo n.º 23
0
def output_peaks_mvalue_2wig_file(pks1_uni, pks2_uni, merged_pks,
                                  comparison_name):
    """
    output of peaks with normed m value and p values
    """
    print 'output wig files ... '

    peaks = _add_peaks(_add_peaks(pks1_uni, merged_pks), pks2_uni)
    f_2write = open('_'.join([comparison_name, 'peaks_Mvalues.wig']), 'w')
    f_2write.write('browser position chr11:5220000-5330000\n')
    f_2write.write('track type=wiggle_0 name=%s' % comparison_name +
                   ' visibility=full autoScale=on color=255,0,0 ' +
                   ' yLineMark=0 yLineOnOff=on priority=10\n')
    for chr_id in peaks.keys():
        f_2write.write('variableStep chrom=' + chr_id + ' span=100\n')
        pks_chr = peaks[chr_id]
        sorted_pks_chr = _sort_peaks_list(pks_chr, 'summit')
        # write sorted peak summit and m-value to file
        [
            f_2write.write('\t'.join(
                ['%d' % pk.summit,
                 '%s\n' % str(pk.normed_mvalue)])) for pk in sorted_pks_chr
        ]
    f_2write.close()

    f_2write = open('_'.join([comparison_name, 'peaks_Pvalues.wig']), 'w')
    f_2write.write('browser position chr11:5220000-5330000\n')
    f_2write.write('track type=wiggle_0 name=%s(-log10(p-value))' %
                   comparison_name +
                   ' visibility=full autoScale=on color=255,0,0 ' +
                   ' yLineMark=0 yLineOnOff=on priority=10\n')
    for chr_id in peaks.keys():
        f_2write.write('variableStep chrom=' + chr_id + ' span=100\n')
        pks_chr = peaks[chr_id]
        sorted_pks_chr = _sort_peaks_list(pks_chr, 'summit')
        # write sorted peak summit and m-value to file
        [
            f_2write.write('\t'.join(
                ['%d' % pk.summit,
                 '%s\n' % str(-log10(pk.pvalue))])) for pk in sorted_pks_chr
        ]
    f_2write.close()
Ejemplo n.º 24
0
def temp(prof, p):
    '''
    Interpolates the given data to calculate a temperature at a given pressure

    Parameters
    ----------
    prof : profile object
        Profile object
    p : number, numpy array
        Pressure (hPa) of the level for which temperature is desired

    Returns
    -------
    Temperature (C) at the given pressure : number, numpy array

    '''
    # Note: numpy's interpoloation routine expects the interpoloation
    # routine to be in ascending order. Because pressure decreases in the
    # vertical, we must reverse the order of the two arrays to satisfy
    # this requirement.
    return generic_interp_pres(ma.log10(p), prof.logp[::-1], prof.tmpc[::-1])
Ejemplo n.º 25
0
def lin2db(array: np.ndarray, scale: int = 10) -> np.ndarray:
    """Linear to dB conversion."""
    if ma.isMaskedArray(array):
        return scale * ma.log10(array)
    return scale * np.log10(array)
Ejemplo n.º 26
0
 def transform_non_affine(self, a):
     a = self._handle_nonpos(a * 10.0)
     if isinstance(a, ma.MaskedArray):
         return ma.log10(a)
     return np.log10(a)
Ejemplo n.º 27
0
def main():
    # parse command-line arguments
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    ## targets to fit
    parser.add_argument("--name", type=str, default=None,
        help="base name of combined skim file")
    parser.add_argument("--subsample-step", type=int, default=1000,
        help="step size used for subsampling observations")
    parser.add_argument("--dont-save", action="store_true",
        help="dont save delta field (just do all the preprocessing)")
    args = parser.parse_args()

    # import data
    skim = h5py.File(args.name+'.hdf5', 'r')
    norm = skim['norm'][:][:,np.newaxis]
    loglam = skim['loglam'][:]
    wave = np.power(10.0, loglam)

    quasar_redshifts = skim['z'][:]

    linear_continuum = h5py.File(args.name+'-linear-continuum.hdf5', 'r')
    params_a = linear_continuum['params_a'].value
    params_b = linear_continuum['params_b'].value
    continuum = linear_continuum['continuum'].value
    continuum_wave = linear_continuum['continuum_wave'].value
    continuum_interp = scipy.interpolate.UnivariateSpline(continuum_wave, continuum, s=0, ext=1)

    wave_lya = linear_continuum.attrs['wave_lya']
    abs_alpha = linear_continuum.attrs['abs_alpha']
    abs_beta = linear_continuum.attrs['abs_beta']
    forest_wave_ref = linear_continuum.attrs['forest_wave_ref']

    print 'Adjusting weights for pipeline variance and LSS variance...'

    forest_min_z = linear_continuum.attrs['forest_min_z']
    forest_max_z = linear_continuum.attrs['forest_max_z']
    forest_dz = 0.1
    forest_z_bins = np.arange(forest_min_z, forest_max_z + forest_dz, forest_dz)
    var_lss = scipy.interpolate.UnivariateSpline(forest_z_bins, 0.05 + 0.06*(forest_z_bins - 2.0)**2, s=0)
    var_pipe_scale = scipy.interpolate.UnivariateSpline(forest_z_bins, 0.7 + 0.2*(forest_z_bins - 2.0)**2, s=0)

    forest_pixel_redshifts = wave/wave_lya - 1
    abs_coefs = abs_alpha*np.power(1+forest_pixel_redshifts, abs_beta)

    forest_wave_refs = forest_wave_ref*(1+quasar_redshifts)
    def model_flux(a, b):
        return a*np.power(wave/forest_wave_refs[:,np.newaxis], b)*continuum_interp(wave/(1+quasar_redshifts[:,np.newaxis]))*np.exp(-abs_coefs)

    mflux = model_flux(params_a[:,np.newaxis],params_b[:,np.newaxis])

    # (1.0 + quasar_redshifts[:,np.newaxis])*forest_wave/args.wave_lya - 1.0

    print forest_pixel_redshifts.shape

    pixel_mask = skim['mask'][:]

    print pixel_mask.shape

    flux = np.ma.MaskedArray(skim['flux'][:], mask=pixel_mask)
    ivar = np.ma.MaskedArray(skim['ivar'][:], mask=pixel_mask)

    delta_flux = flux/mflux - 1.0
    delta_ivar = ivar*mflux*mflux

    delta_weight = delta_ivar*var_pipe_scale(forest_pixel_redshifts)
    delta_weight = delta_weight/(1 + delta_weight*var_lss(forest_pixel_redshifts))

    redshift_order = np.argsort(quasar_redshifts)
    export_exact_image(args.name+'-delta-flux.png', delta_flux[redshift_order][::args.subsample_step], dpi=100,
        vmin=-5, vmax=5, cmap=plt.get_cmap('bwr'), origin='lower')
    export_exact_image(args.name+'-delta-weight.png', ma.log10(delta_flux[redshift_order][::args.subsample_step]), dpi=100,
        vmin=-5, vmax=2, cmap=plt.get_cmap('Purples'), origin='lower')
    export_exact_image(args.name+'-delta-mask.png', pixel_mask[redshift_order][::args.subsample_step], dpi=100,
        origin='lower')

    print 'Computing mean delta...'

    mask_params = (params_a > .1) & (params_a < 10) & (params_b > -10) & (params_b < 10)

    delta_mean = ma.average(delta_flux[mask_params], axis=0)
    delta_mean_weighted = ma.average(delta_flux[mask_params], weights=delta_weight[mask_params], axis=0)
    delta_mean_ivar_weighted = ma.average(delta_flux[mask_params], weights=delta_ivar[mask_params], axis=0)

    plt.figure(figsize=(12,9))
    plt.plot(wave, delta_mean, label='Unweighted Mean')
    plt.plot(wave, delta_mean_weighted, label='LSS weighted Mean')
    plt.plot(wave, delta_mean_ivar_weighted, label='Ivar weighted Mean')
    # plt.ylim(0.06*np.array([-1,1]))
    plt.xlabel(r'Observed Wavelength ($\AA$)')
    plt.ylabel(r'Delta Mean')
    plt.grid()
    plt.legend()
    plt.savefig(args.name+'-lssweighted-delta-mean.png', dpi=100, bbox_inches='tight')
    plt.close()

    if args.dont_save:
        return -1

    outfile = h5py.File(args.name+'-delta.hdf5', 'w')
    # copy attributes from input files
    for attr_key in skim.attrs:
        outfile.attrs[attr_key] = skim.attrs[attr_key]
    # it's okay to overwrite the few that were already copied, I added a few attr to the combined
    # skim file and dont want to run the whole chain just yet
    for attr_key in linear_continuum.attrs:
        outfile.attrs[attr_key] = linear_continuum.attrs[attr_key]
    # create los group
    lines_of_sight = outfile.create_group('lines_of_sight')

    outfile.create_dataset('delta_mean', data=delta_mean.data)

    # loop over targets
    progress_bar = ProgressBar(widgets=[Percentage(), Bar()], maxval=len(quasar_redshifts)).start()
    for i, z in enumerate(quasar_redshifts):
        progress_bar.update(i)

        if not mask_params[i]:
            # print 'fit param outside nominal range'
            continue

        z = quasar_redshifts[i]
        a = params_a[i]
        b = params_b[i]
        norm_i = norm[i]
        meta = skim['meta'][i]

        assert norm_i > 0

        ra = float(meta['ra'])
        dec = float(meta['dec'])
        thing_id = meta['thing_id']
        plate = meta['plate']
        mjd = meta['mjd']
        fiber = meta['fiber']

        # save to hdf5 file
        los = lines_of_sight.create_group(str(thing_id))
        los.attrs['plate'] = plate
        los.attrs['mjd'] = mjd
        los.attrs['fiber'] = fiber
        los.attrs['ra'] = ra
        los.attrs['dec'] = dec
        los.attrs['z'] = z
        los.attrs['p0'] = a
        los.attrs['p1'] = b

        los.create_dataset('loglam', data=loglam, dtype='f4')
        los.create_dataset('delta', data=(delta_flux[i]-delta_mean_weighted), dtype='f8')
        los.create_dataset('weight', data=delta_weight[i], dtype='f8')
        los.create_dataset('r_comov', data=np.zeros_like(loglam), dtype='f4')
        # los.create_dataset('ivar', data=ivar[i]/(norm_i*norm_i), dtype='f4')
        los.create_dataset('ivar', data=delta_ivar[i], dtype='f4')

    outfile.close()
    progress_bar.finish()
Ejemplo n.º 28
0
 def transform(self, a):
     a = _mask_non_positives(a * 10.0)
     if isinstance(a, MaskedArray):
         return ma.log10(a)
     return np.log10(a)
Ejemplo n.º 29
0
def _lin2log(*args: ndarray) -> list:
    return [ma.log10(x) for x in args]
Ejemplo n.º 30
0
#mask land values
Land = ma.getmask(varname)
Landdt = rt.AddDepthTime(RomsFile, Land)


Xratio = ma.array(x_rat, mask = Land).flatten()
Yratio = ma.array(y_rat, mask = Land).flatten()

#remove mask
Xratio = Xratio[~Xratio.mask]
Yratio = Yratio[~Yratio.mask]

X_good = Xratio !=0
Y_good = Yratio !=0

xlog = ma.log10(Xratio[X_good])
ylog = ma.log10(Yratio[Y_good])

#depth
romsvars = {'h' : RomsNC.variables['h'][:], \
            'zeta' : RomsNC.variables['zeta'][:]}
    
#compute depth at rho points
depth = dep._set_depth_T(RomsFile, None, 'rho', romsvars['h'], romsvars['zeta'])
depth = ma.array(depth, mask = Land).flatten()

_dep = depth[X_good]
depthLR = _dep[xlog > 1]
depthLR = depthLR[~depthLR.mask]

where_are_NaNs = isnan(img_masked1)
img_masked1[where_are_NaNs] = 0

plt.imshow(img_masked1, origin = 'lower',aspect='auto') 
plt.pcolor(img_masked1,norm=LogNorm()) 
plt.set_cmap('seismic')
cbar=plt.colorbar() 


with np.errstate(divide='ignore', invalid='ignore'):
    ratio = np.true_divide(img_masked,img_masked1)
    ratio[ratio == np.inf] = 0
    ratio= np.nan_to_num(ratio)

 ratio_norm=ratio/2.76
  balmer = 2.5*(ma.log10(ratio_norm))

plt.imshow(balmer, origin = 'lower',aspect='auto') 
plt.pcolor(balmer,norm=LogNorm()) 
plt.set_cmap('jet')
cbar=plt.colorbar() 


ratio_norm=ratio/2.76
balmer = 2.5*(ma.log(ratio_norm))
print balmer.filled(0)
outfile = 'balmer.fits.gz'

hdu = fits.PrimaryHDU(balmer)
hdu.writeto(outfile, clobber=True)
Ejemplo n.º 32
0
def BHOSS2fits(filename,freq,source,date,history,user,plot=1,show=False):

    ##some definitions
    DEGREE = 3.141592653589/180.0
    HOUR = 15.0*DEGREE
    RADPERAS = DEGREE/3600.0
    RADPERUAS = RADPERAS*1.e-6

    #get file name
    filename_load=filename
    tmp=filename.split('_')

    #get source postion
    loc=SkyCoord.from_name(source)

    #get RA and DEC in degree
    ra=loc.ra.deg
    dec=loc.dec.deg

    #convert date to mjd (modified julian date)
    modjuldate=(aTime(date)).mjd
    
    #get BHOSS GRRT file based on Z. Younsi script
    #--> needs to be updated once the BHOSS header is modified!!!!
    #
    
    # First header line: [image width, offset, resolution, # of observational frequencies]
    header_1 = np.genfromtxt(filename, max_rows = 1)
    # Second header line: [observational time, inclination, BH spin parameter, Luminosity F_nu correction to erg Hz, Jansky correction to Jy Hz ]
    header_2 = np.genfromtxt(filename, skip_header = 1, max_rows = 1)
    # Third header line: observational frequencies of interest
    header_3 = np.genfromtxt(filename, skip_header = 2, max_rows = 1)


    width       = header_1[0]
    offset      = header_1[1]
    M           = int(header_1[2])
    s1          = width + offset
    s2          = 2*width/(M - 1)
    N_obs_freqs = header_1[3]

    time        = header_2[0]
    inclination = header_2[1]
    phi         = header_2[2]
    spin        = header_2[3]
    L_corr      = header_2[4]
    Jansky_corr = header_2[5]

    
    if source=='SgrA*':
        Micro_Arcsecond_Corr = 5.04975 # New value based on Boehle et al. 2016
    if source=='M 87':
        Micro_Arcsecond_Corr = 3.622197344489511 # New value based from Yosuke for M87

    width_scaled         = Micro_Arcsecond_Corr*width   # Scale from r_g to micro-arcseconds


    #find select frequency within computed freqs
    ind=np.where(header_3==freq)

    if len(ind[0])<1:
        sys.exit('EXIT:freq not in GRRT file. Available freqs are %s' %str((header_3)))
    else:
        
        freq_ID=ind[0][0]+3
    print header_3
    print header_3[freq_ID-3]
    # Now read in all image data
    ascii2 = np.loadtxt(filename_load, skiprows = 3, usecols = (0, 1, freq_ID))
    data2=ascii2.reshape([M, M, 3])

    # Convert from indices to (alpha,beta), in units of r_g, on the image plane
    x = -s1 + s2*(data2[:,:,0] - 1)
    y = -s1 + s2*(data2[:,:,1] - 1)


    # Convert (alpha,beta) into micro-arcseconds
    x = Micro_Arcsecond_Corr*x
    y = Micro_Arcsecond_Corr*y

    xmax    = np.amax(x)
    xmin    = np.amin(x)
    ymax    = np.amax(y)
    ymin    = np.amin(y)

    #flux in Jansky
    jansky=(data2[:,:,2]*Jansky_corr)

    #create pixel size
    dxorg=(xmax-xmin)/x.shape[0]
    dyorg=(ymax-ymin)/y.shape[0]
    dim=x.shape[0]
    print('image resolution %f' %(dxorg))
    print('org res. total flux:', ma.sum(jansky), 'max flux:',ma.amax(jansky))


    #create fits file

    # Create header and fill in some values
    header = fits.Header()
    header['AUTHOR'] =  user
    header['OBJECT'] =  source
    header['CTYPE1'] = 'RA---SIN'
    header['CTYPE2'] = 'DEC--SIN'
    header['CDELT1'] = -dxorg*RADPERUAS/DEGREE
    header['CDELT2'] =  dxorg*RADPERUAS/DEGREE
    header['OBSRA'] = ra
    header['OBSDEC'] = dec
    header['FREQ'] = freq
    header['MJD'] = float(modjuldate)
    header['TELESCOP'] = 'VLBI'
    header['BUNIT'] = 'JY/PIXEL'
    header['STOKES'] = 'I'
    header['HISTORY'] = history
    hdu = fits.PrimaryHDU(jansky, header=header)
    hdulist = [hdu]

    hdulist = fits.HDUList(hdulist)

    # Save fits
    tmp=filename.split('/')
    outname=tmp[-1]
    hdulist.writeto('FITS/%s_%i_%iGHz.fits' %(outname[:-4],dim,(freq/1e9)), overwrite=True)

    
    if plot==1:
            
            #create image (normalised)
            fonts=12
            cmap='cubehelix'
            fig=plt.figure(figsize=(7,8))
            plt.subplots_adjust(left=0.15, bottom=0.1, right=0.95, top=0.85, wspace=0.00001, hspace=0.00001)

            ax=fig.add_subplot(111,frame_on='True',aspect='equal',axisbg='k')
            #i1=ax.imshow(jansky/ma.amax(jansky),origin='lower', vmin=0,vmax=1,extent=[xmax, xmin, ymin, ymax], interpolation="bicubic",cmap=cmap )
            i1=ax.imshow(ma.log10(jansky),origin='lower',vmin=-10,vmax=ma.log10(0.05),extent=[xmax, xmin, ymin, ymax], interpolation="bicubic",cmap=cmap )

            
            ax.annotate(r'$\mathrm{%s}$' %(source), xy=(0.1, 0.91),xycoords='axes fraction', fontsize=18,
                            horizontalalignment='left', verticalalignment='bottom', color='w')
            ax.annotate(r'$\mathrm{{\nu=%i\,GHz}}$' %(freq/1e9), xy=(0.1, 0.81),xycoords='axes fraction', fontsize=18,
                            horizontalalignment='left', verticalalignment='bottom', color='w')
    


            #set axis
            plt.xlabel('relative R.A [$\mu$as]', fontsize=fonts)
            plt.ylabel('relative DEC [$\mu$as]', fontsize=fonts)


            #set position of colorbar
            p1=ax.get_position().get_points().flatten()
            ax11 = fig.add_axes([p1[0], p1[3], p1[2]-p1[0], 0.02])
            t1=plt.colorbar(i1,cax=ax11,orientation='horizontal',format='%1.1f')
            #t1.set_label(r'$\rm{S/S}_{\rm{max}}$',fontsize=fonts+4,labelpad=-65)
            t1.set_label(r'$\log_{10}(S)\,\mathrm{[Jy/pixel]}$',fontsize=fonts+4,labelpad=-65)
            t1.ax.xaxis.set_ticks_position('top')
            t1.ax.tick_params(labelsize=fonts) 


            #set xmax left and ticks
            ax.set_xlim(xmax,xmin)
            ax.set_ylim(ymin,ymax)
            ax.yaxis.set_major_locator(plt.MultipleLocator(20))
            ax.yaxis.set_minor_locator(plt.MultipleLocator(5))
            ax.xaxis.set_major_locator(plt.MultipleLocator(20))
            ax.xaxis.set_minor_locator(plt.MultipleLocator(5))

            for spine in ax.spines.values():
                spine.set_edgecolor('w')

            #settings for axes and tickmarks
            for label in ax.xaxis.get_ticklabels():
                label.set_fontsize(fonts)

            for label in ax.yaxis.get_ticklabels():
                label.set_fontsize(fonts)
            for tick in ax.xaxis.get_major_ticks():
                tick.tick1line.set_color('w')
                tick.tick2line.set_color('w')
                tick.tick1line.set_markersize(14)
                tick.tick2line.set_markersize(14)
            for tick in ax.xaxis.get_minor_ticks():
                tick.tick1line.set_color('w')
                tick.tick2line.set_color('w')
                tick.tick1line.set_markersize(10)
                tick.tick2line.set_markersize(10)
            for tick in ax.yaxis.get_major_ticks():
                tick.tick1line.set_color('w')
                tick.tick2line.set_color('w')
                tick.tick1line.set_markersize(14)
                tick.tick2line.set_markersize(14)
            for tick in ax.yaxis.get_minor_ticks():
                tick.tick1line.set_color('w')
                tick.tick2line.set_color('w')
                tick.tick1line.set_markersize(10)
                tick.tick2line.set_markersize(10)

            #save image
            plt.savefig('IMAGE/%s_%i_%iGHz.pdf' %(source,dim,(freq/1e9)),dpi=150, bbox_inches='tight', pad_inches = 0.04)
            if show==True:
                plt.show()

    return {'image':jansky,'dx':dxorg,'dy':dyorg}
    for i in range(1,m):
        ka += a[m-2,i-1]*Rx[m-i]
    ka += Rx[m]
    kb = -P[m-1]
    k.append(ka/kb)
    a[m-1,m-1] = ka/kb
    for i in range(1,m):
        a[m-1,i-1] = a[m-2,i-1]+k[m-1]*a[m-2,m-i-1]
    P.append(P[m-1]*(1-k[m-1]**2))
hb=[1]
for i in range(0,p):
    hb.append(a[p-1,i])
#把0阶的最小预测误差功率从P[]中删除
P.remove(P[0])
ha=[1]
w,H = signal.freqz(ha,hb)
G_2 = P[p-1]
PSD = G_2*((np.abs(H))**2)
PSD1 = 10*log10(PSD)
plt.figure(figsize=(10, 28))
plt.subplot(511)
plt.plot(x_n)
plt.grid(True,linestyle = "--",color = 'gray' ,linewidth = '0.5',axis='both')

plt.subplot(512)
plt.plot(w/(2*pi),abs(PSD1))
plt.grid(True,linestyle = "--",color = 'gray' ,linewidth = '0.5',axis='both')

f = findpeak(w,PSD1,N,f1,f2)
print(f)
Ejemplo n.º 34
0
 def transform_non_affine(self, a):
     a = self._handle_nonpos(a * 10.0)
     if isinstance(a, ma.MaskedArray):
         return ma.log10(a)
     return np.log10(a)
Ejemplo n.º 35
0
def draw_figs_to_show_data(pks1_uni, pks2_uni, merged_pks, pks1_name,
                           pks2_name, ma_fit, reads1_name, reads2_name):
    """
    draw four figures to show data before and after rescaled
    """
    pks_3set = [pks1_uni, pks2_uni, merged_pks]
    pks1_name = ' '.join([pks1_name, 'unique'])
    pks2_name = ' '.join([pks2_name, 'unique'])
    merged_pks_name = 'merged common peaks'
    pks_names = [pks1_name, pks2_name, merged_pks_name]
    colors = 'bgr'
    a_max = 0
    a_min = 10000
    plt.figure(1).set_size_inches(16, 12)
    for (idx, pks) in enumerate(pks_3set):
        mvalues, avalues = get_peaks_mavalues(pks)
        if len(avalues) != 0:
            a_max = max(max(avalues), a_max)
            a_min = min(min(avalues), a_min)
        plt.scatter(avalues, mvalues, s=10, c=colors[idx])
    plt.xlabel('A value')
    plt.ylabel('M value')
    plt.grid(axis='y')
    plt.legend(pks_names, loc='best')
    plt.title('before rescale')

    # plot the fitting model into figure 1
    x = np.arange(a_min, a_max, 0.01)
    y = ma_fit[1] * x + ma_fit[0]
    plt.plot(x, y, '-', color='k')
    plt.savefig('before_rescale.png')

    # plot the scatter plots of read count in merged common peaks between two chip-seq sets
    plt.figure(2).set_size_inches(16, 12)
    rd_min = 1000
    rd_max = 0
    rds_density1, rds_density2 = [], []
    for key in merged_pks.keys():
        for pk in merged_pks[key]:
            rds_density1.append(pk.read_density1), rds_density2.append(
                pk.read_density2)
    rd_max = max(max(log2(rds_density1)), rd_max)
    rd_min = min(min(log2(rds_density1)), rd_min)
    plt.scatter(log2(rds_density1),
                log2(rds_density2),
                s=10,
                c='r',
                label=merged_pks_name,
                alpha=0.5)
    plt.xlabel(' log2 read density' + ' by ' + '"' + reads1_name + '" reads')
    plt.ylabel(' log2 read density' + ' by ' + '"' + reads2_name + '" reads')
    plt.grid(axis='y')
    plt.legend(loc='upper left')
    plt.title('Fitting Model via common peaks')
    rx = np.arange(rd_min, rd_max, 0.01)
    ry = (2 - ma_fit[1]) * rx / (2 + ma_fit[1]) - 2 * ma_fit[0] / (2 +
                                                                   ma_fit[1])
    plt.plot(rx, ry, '-', color='k')
    plt.savefig('log2_read_density.png')

    # plot the MA plot after rescale
    plt.figure(3).set_size_inches(16, 12)
    for (idx, pks) in enumerate(pks_3set):
        normed_mvalues, normed_avalues = get_peaks_normed_mavalues(pks)
        plt.scatter(normed_avalues, normed_mvalues, s=10, c=colors[idx])
    plt.xlabel('A value')
    plt.ylabel('M value')
    plt.grid(axis='y')
    plt.legend(pks_names, loc='best')
    plt.title('after rescale')
    plt.savefig('after_rescale.png')

    # generate MA plot for this set of peaks together with p-value
    plt.figure(4).set_size_inches(16, 12)
    for (idx, pks) in enumerate(pks_3set):
        normed_mvalues, normed_avalues = get_peaks_normed_mavalues(pks)
        colors = -log10(get_peaks_pvalues(pks))
        for i, c in enumerate(colors):
            if c > 50:
                colors[i] = 50
        plt.scatter(normed_avalues, normed_mvalues, s=10, c=colors, cmap='jet')
    plt.colorbar()
    plt.grid(axis='y')
    plt.xlabel('A value')
    plt.ylabel('M value')
    plt.title('-log10(P-value)')
    plt.savefig('-log10_P-value.png')
    plt.close()
Ejemplo n.º 36
0
def _lin2log(*args):
    return [ma.log10(x) for x in args]
Ejemplo n.º 37
0
 def transform_non_affine(self, a):
   masked = ma.masked_where(a > 1-10**(-1-self.nines), a)
   if masked.mask.any():
     return -ma.log10(1-a)
   else:
     return -np.log10(1-a)
Ejemplo n.º 38
0
 def transform_non_affine(self, a):
     masked = ma.masked_where(a > 1 - 10**(-1 - self.nines), a)
     if masked.mask.any():
         return -ma.log10(1 - a)
     else:
         return -np.log10(1 - a)
Ejemplo n.º 39
0
    def __call__(self, value, clip=None):

        #read in parameters
        method = self.stretch
        exponent = self.exponent
        midpoint = self.midpoint

        # ORIGINAL MATPLOTLIB CODE

        if clip is None:
            clip = self.clip

        if cbook.iterable(value):
            vtype = 'array'
            val = ma.asarray(value).astype(np.float)
        else:
            vtype = 'scalar'
            val = ma.array([value]).astype(np.float)

        self.autoscale_None(val)
        vmin, vmax = self.vmin, self.vmax
        if vmin > vmax:
            raise ValueError("minvalue must be less than or equal to maxvalue")
        elif vmin==vmax:
            return 0.0 * val
        else:
            if clip:
                mask = ma.getmask(val)
                val = ma.array(np.clip(val.filled(vmax), vmin, vmax),
                                mask=mask)
            result = (val-vmin) * (1.0/(vmax-vmin))

            # CUSTOM APLPY CODE

            # Keep track of negative values
            negative = result < 0.

            if self.stretch == 'linear':

                pass

            elif self.stretch == 'log':

                result = ma.log10(result * (self.midpoint - 1.) + 1.) \
                       / ma.log10(self.midpoint)

            elif self.stretch == 'sqrt':

                result = ma.sqrt(result)

            elif self.stretch == 'arcsinh':

                result = ma.arcsinh(result/self.midpoint) \
                       / ma.arcsinh(1./self.midpoint)

            elif self.stretch == 'power':

                result = ma.power(result, exponent)

            else:

                raise Exception("Unknown stretch in APLpyNormalize: %s" %
                                self.stretch)

            # Now set previously negative values to 0, as these are
            # different from true NaN values in the FITS image
            result[negative] = -np.inf

        if vtype == 'scalar':
            result = result[0]

        return result
Ejemplo n.º 40
0
def find_max(array_like):
    no_zeros = array_like[nonzero(array_like)]
    with errstate(all='ignore'):
        max = nanmax(10 ** log10(no_zeros))
    return max
Ejemplo n.º 41
0
    def __call__(self, value, clip=None):

        #read in parameters
        method = self.stretch
        exponent = self.exponent
        midpoint = self.midpoint

        # ORIGINAL MATPLOTLIB CODE

        if clip is None:
            clip = self.clip

        if cbook.iterable(value):
            vtype = 'array'
            val = ma.asarray(value).astype(np.float)
        else:
            vtype = 'scalar'
            val = ma.array([value]).astype(np.float)

        self.autoscale_None(val)
        vmin, vmax = self.vmin, self.vmax
        if vmin > vmax:
            raise ValueError("minvalue must be less than or equal to maxvalue")
        elif vmin == vmax:
            return 0.0 * val
        else:
            if clip:
                mask = ma.getmask(val)
                val = ma.array(np.clip(val.filled(vmax), vmin, vmax),
                               mask=mask)
            result = (val - vmin) * (1.0 / (vmax - vmin))

            # CUSTOM APLPY CODE

            # Keep track of negative values
            negative = result < 0.

            if self.stretch == 'linear':

                pass

            elif self.stretch == 'log':

                result = ma.log10(result * (self.midpoint - 1.) + 1.) \
                       / ma.log10(self.midpoint)

            elif self.stretch == 'sqrt':

                result = ma.sqrt(result)

            elif self.stretch == 'arcsinh':

                result = ma.arcsinh(result / self.midpoint) \
                       / ma.arcsinh(1. / self.midpoint)

            elif self.stretch == 'power':

                result = ma.power(result, exponent)

            else:

                raise Exception("Unknown stretch in APLpyNormalize: %s" %
                                self.stretch)

            # Now set previously negative values to 0, as these are
            # different from true NaN values in the FITS image
            result[negative] = -np.inf

        if vtype == 'scalar':
            result = result[0]

        return result
Ejemplo n.º 42
0
 def transform(self, a):
     a = _mask_non_positives(a * 10.0)
     if isinstance(a, MaskedArray):
         return ma.log10(a)
     return np.log10(a)