Beispiel #1
0
def cheb1Dfit(x, y, order=5, weight=None, niteration=0, \
              high_nsig=0.0, low_nsig=0.0):
    stat = True
    n = len(x)
    if weight is None:
        weight1 = np.ones(n)
    else:
        weight1 = copy.deepcopy(weight)

    c = chebfit(x,y,order,w=weight1)
    for k in range(niteration):
        residualdata = y - chebval(x,c)
        # Calculating weighted standard deviation
        mean, sig = weighted_average_std(residualdata, weight1)

        # Clipiing the data
        if mean != 0:
            if sig/mean > 1.0e-10 or sig/mean < -1.0e-10:
                highlimit = high_nsig * sig
                lowlimit = -low_nsig * sig
                for j in range(n):
                    if residualdata[j] > highlimit or residualdata[j] < lowlimit:
                        weight1[j] = 0.0
                
        # Fitting again
        with warnings.catch_warnings():
            warnings.filterwarnings("error")
            try:
                c = chebfit(x,y,order,w=weight1)
            except np.polynomial.polyutils.RankWarning:
                print('RankWarning')
                stat = False

    return c, weight1, stat
Beispiel #2
0
    def normalize_spectra(self):
        """
        Normalize the data and model spectra
        """
        self.spectra['m_flux_norm'] = deepcopy(self.spectra['m_flux'])
        self.spectra['d_flux_norm'] = deepcopy(self.spectra['d_flux'])
        self.spectra['unc_norm'] = deepcopy(self.spectra['unc'])

        chunks = 1000
        min_ = min(self.spectra['wave'])
        max_ = max(self.spectra['wave'])
        num = int((max_ - min_) / chunks) + 1

        for i in range(num):
            k = ((self.spectra['wave'] >= min_ + chunks * i) &
                 (self.spectra['wave'] <= min_ + chunks * (i + 1)))

            if len(self.spectra['d_flux_norm'][k]) < 10:
                continue

            coeffs = chebfit(self.spectra['wave'][k],
                             self.spectra['d_flux_norm'][k], 2)
            poly = chebval(self.spectra['wave'][k], coeffs)
            self.spectra['d_flux_norm'][
                k] = self.spectra['d_flux_norm'][k] / poly
            self.spectra['unc_norm'][k] = self.spectra['unc_norm'][k] / poly

            coeffs = chebfit(self.spectra['wave'][k],
                             self.spectra['m_flux_norm'][k], 2)
            poly = chebval(self.spectra['wave'][k], coeffs)
            self.spectra['m_flux_norm'][
                k] = self.spectra['m_flux_norm'][k] / poly
Beispiel #3
0
def polyLine(startPt, endPt, polyIndex, t, sgf, data):
    x = []
    y = []
    vt = []
    for j in range(startPt, endPt):  #for loop 特性,需要到endpt 因此要+1
        x.append(t[j])
        y.append(float(sgf[j]))
        vt.append(float(data[j]))
    #=================Polyfit 回歸多項式 =========
    # =============================================================================
    #                     tp=np.polyfit(x,y,polyIndex)
    #                     ys_line=np.polyval(tp,x)
    # =============================================================================
    #=================chebyshev 回歸多項式 =========

    coeffRaw = chy.chebfit(x, vt, polyIndex)
    coeffSGF = chy.chebfit(x, y, polyIndex)
    ys_lineRaw = chy.chebval(x, coeffRaw)
    ys_lineSGF = chy.chebval(x, coeffSGF)

    #=================rsq: 決定係數=========
    rsqSGF = round(
        coeff_of_determination(np.array(y), ys_lineRaw, startPt, endPt), 2)
    rsqRW = round(
        coeff_of_determination(np.array(vt), ys_lineRaw, startPt, endPt), 2)
    return coeffRaw, ys_lineRaw, rsqSGF, rsqRW
Beispiel #4
0
    def define_background(self, q, I, k, plot=False, az_idx=0):
        """ Background profile - q, I points with Chebdev poly fit.

        Can supply 2d array for q and I, which define the background
        intensity as a function of azimuthal position. This is predominantly
        for use with the pyxe package!

        Args:
            q (ndarray): 1d or 2d array with q positions
            I (ndarray): 1d or 2d array with intensity values
            k (int): Order for Cheyshev polynomial
            plot (bool): True/False
            az_idx (int): Azimuthal slice to plot
        """
        # Calculate fit and apply to all slices
        if np.array(q).ndim == 1:
            f = chebfit(q, I, k)
        # Calculate fit for each slice
        else:
            assert self.phi.size == q.shape[0]
            f = np.zeros((self.q.shape[0], k + 1))

            for az in range(q.shape[0]):
                finite = np.isfinite(q[az])
                f[az] = chebfit(q[az][finite], I[az][finite], k)

        if plot:
            plt.plot(self.q, chebval(self.q, f[az_idx]), 'k-')
            x = q[az_idx] if q.ndim == 2 else q
            y = I[az_idx] if q.ndim == 2 else I
            plt.plot(x, y, 'r+')
            plt.show()
        self._back = f
Beispiel #5
0
def handle_summary(outname=None, filelist=[]):
    """Extract all std-correction vectors and create ensemble (obsolete)"""

    if outname is None:
        outname = 'correction.npy'

    # Get a list of good correction vectors
    keepers = []
    for ifile in filelist:
        print ifile
        f = np.load(ifile)[0]
        # Correction values should be small
        # if "std-correction" not in data.keys():
        if np.nanmin(f['std-correction']) < 9:
            keepers.append(f)
            print "Keeping %s" % ifile

    # Set fiducial wavelengths from first correction vector
    corl = keepers[0]['nm'].copy()
    # Insert first vector
    cor = np.zeros((len(corl), len(keepers)))
    cor[:, 0] = keepers[0]['std-correction'].copy()
    # Insert the rest of the vectors
    for ix, keeper in enumerate(keepers[1:]):
        f = interp1d(keeper['nm'], keeper['std-correction'],
                     bounds_error=False, fill_value=np.nan)
        cor[:, ix] = f(corl)
    # Create mean correction
    cs = np.nanmean(cor, 1)
    # Fit wl coefficients
    ccs = chebfit(corl, cs, 6)
    # Create output
    cor = [{"nm": corl, "cor": cs, "coeff": ccs}]
    np.save(outname, cor)
Beispiel #6
0
def main(plot=False):
    warnings.filterwarnings('error', category=RuntimeWarning)
    days, fuel_mass, uglovi, snaga = pop_init(gen=1)
    print(days.shape)
    print(fuel_mass.shape)
    print(uglovi.shape)
    print(snaga.shape)
    pop_fit = np.empty(broj_jedinki)
    koeficijenti = np.empty((broj_jedinki, podaci.chebdeg + 1))
    fitness = np.loadtxt('gen_99.txt', dtype=float, usecols=364)
    ind = np.argmin(fitness)
    pop_elita = None
    print('Fitness: ', fitness[ind])
    for i in range(broj_gen):
        for j in range(30, 40):
            print(j)
            print('File fitness: ', fitness[j])
            print('Launch offset:', days[j])
            print('Fuel mass:', fuel_mass[j] / 255 * podaci.max_fuel_mass)
            #print('Uglovi:', (uglovi[j]%(2*pi))*360/(2*pi))
            _r, _, _, min_dist_dest = simulacija_pogon.simulacija(
                days[j], fuel_mass[j], uglovi[j], snaga[j], y_max)
            # if pop_fit[j] == -1:
            pop_fit[j] = fitnes(min_dist_dest)
            koeficijenti[j] = chebfit(x_osa(broj_segmenata), uglovi[j],
                                      podaci.chebdeg)
            if plot:
                x, y = crtanje_planeta(plot=False)
                plt.plot(np.array(x[2]) / au,
                         np.array(y[2]) / au,
                         'b--',
                         np.array(x[3]) / au,
                         np.array(y[3]) / au,
                         'r-.',
                         _r[:, 0] / au,
                         _r[:, 1] / au,
                         'g:',
                         linewidth=0.9)
                plt.plot(0.0, 0.0, 'k*', markersize=7)
                plt.axis('scaled')
                plt.xlabel('x-osa [astronomska jedinica]')
                plt.ylabel('y-osa [astronomska jedinica]')
                plt.title('Flyby Marsa')
                plt.show()
        # print(podaci.trajanje)
        # pop_bit = np.array([[0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 15.1],
        #                    [1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 5.6],
        #                    [0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 10.8],
        #                    [1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 2.6],
        #                    [0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 4.9]])
        # pop_elita = np.array([[0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1.5]])
        pop_bit = float_to_bit(days[:, np.newaxis], fuel_mass, koeficijenti,
                               snaga)
        # print(pop_bit)
        pop_bit_new, pop_elita = genetski_algoritam.genetski_algoritam(
            pop_bit, pop_elita, podaci.p_elit, podaci.p_mut)
        # print(pop_bit_new)
        # print(pop_elita)
        # date_time, fuel_mass, uglovi, snaga = bit_to_float(pop_bit_new)
        print(np.min(pop_fit))
Beispiel #7
0
def fit_poly(w, r, type, order):
    if type == "legendre":
        coef = legfit(w, r, order)
        return coef
    elif type == "chebyshev":
        coef = chebfit(w, r, order)
        return coef
Beispiel #8
0
def handle_summary(outname=None, filelist=[]):
    if outname is None: outname = 'correction.npy'

    keepers = []
    for file in filelist: 
        print file
        f = np.load(file)[0]
        if np.nanmin(f['std-correction']) < 9:
            keepers.append(f)
            print "Keeping %s" % file


    corl = keepers[0]['nm'].copy()
    cor = np.zeros((len(corl), len(keepers)))
    cor[:,0] = keepers[0]['std-correction'].copy()
    for ix, keeper in enumerate(keepers[1:]):
        f = interp1d(keeper['nm'], keeper['std-correction'], bounds_error=False, 
            fill_value = np.nan)

        cor[:,ix] = f(corl)

    cs = np.nanmean(cor,1)
    ccs = chebfit(corl, cs, 6)

    cor = [{"nm": corl, "cor": cs, "coeff": ccs}]
    np.save(outname, cor)
Beispiel #9
0
def cheb_fitcurve(x, y, order):
    x = cheb.chebpts2(len(x))
    order = 64
    coef = legend.legfit(x, y, order)
    assert_equal(len(coef), order + 1)
    y1 = legend.legval(x, coef)
    err_1 = np.linalg.norm(y1 - y) / np.linalg.norm(y)

    coef = cheb.chebfit(x, y, order)
    assert_equal(len(coef), order + 1)
    thrsh = abs(coef[0] / 1000)
    for i in range(len(coef)):
        if abs(coef[i]) < thrsh:
            coef = coef[0:i + 1]
            break

    y2 = cheb.chebval(x, coef)
    err_2 = np.linalg.norm(y2 - y) / np.linalg.norm(y)

    plt.plot(x, y2, '.')
    plt.plot(x, y, '-')
    plt.title("nPt={} order={} err_cheby={:.6g} err_legend={:.6g}".format(
        len(x), order, err_2, err_1))
    plt.show()
    assert_almost_equal(cheb.chebval(x, coef), y)
    #
    return coef
def polyLine(startPt, endPt, polyIndex, t, sgf, data):
    x = []
    y = []
    vt = []
    for j in range(startPt, endPt):  #for loop 特性,需要到endpt 因此要+1
        x.append(t[j])
        y.append(float(sgf[j]))
        vt.append(float(data[j]))
    #=================Polyfit 回歸多項式 =========
    # =============================================================================
    #                     tp=np.polyfit(x,y,polyIndex)
    #                     ys_line=np.polyval(tp,x)
    # =============================================================================
    #=================chebyshev 回歸多項式 =========
    coeff = chy.chebfit(x, y, polyIndex)
    # =============================================================================
    #     print(chy.Chebyshev.fit(x,y,polyIndex))
    #     print(coeff)
    #     print(np.poly1d(coeff))
    # =============================================================================
    ys_line = chy.chebval(x, coeff)
    # =============================================================================
    #     approximated_values = np.poly1d(coeff)(x)
    #     print(ys_line,approximated_values)
    # =============================================================================
    #=================rsq: 決定係數=========
    rsqSGF = round(
        coeff_of_determination(np.array(y), ys_line, startPt, endPt), 3)
    rsqTT = round(
        coeff_of_determination(np.array(vt), ys_line, startPt, endPt), 3)
    return coeff, ys_line, rsqSGF, rsqTT
Beispiel #11
0
def che_fit(txt_path, deg, fit_save_dir):
    '''
    input : a txt of    label, imgw, imgh, x, y, w, h, centerx, centery, 360deg 
    return label, imgw, imgh, x, y, w, h, centerx, centery, coef(16,24)
    '''
    with open(txt_path, 'r') as f:
        img_info = np.loadtxt(txt_path)
        img_info = img_info.reshape(-1, 369)
        new_path = os.path.join(fit_save_dir, txt_path.split('/')[-1])

        results = []
        for objects_info in img_info:
            # 1,360
            objects_new = np.zeros(9 + deg + 1)
            objects_new[0:9] = objects_info[0:9]
            bboxw = objects_info[5]
            bboxh = objects_info[6]
            bbox_len = np.sqrt(bboxw * bboxw + bboxh * bboxh)
            r = objects_info[9:] / float(bbox_len)
            theta = np.linspace(-1, 1, 360)
            coefficient, Res = chebyshev.chebfit(theta, r, deg, full=True)
            objects_new[9:] = np.array(coefficient)
            results.append(objects_new)
        results = np.array(results)
        np.savetxt(new_path, results)
Beispiel #12
0
def handle_summary(outname=None, filelist=[]):
    if outname is None: outname = 'correction.npy'

    keepers = []
    for file in filelist:
        print file
        f = np.load(file)[0]
        if np.nanmin(f['std-correction']) < 9:
            keepers.append(f)
            print "Keeping %s" % file

    corl = keepers[0]['nm'].copy()
    cor = np.zeros((len(corl), len(keepers)))
    cor[:, 0] = keepers[0]['std-correction'].copy()
    for ix, keeper in enumerate(keepers[1:]):
        f = interp1d(keeper['nm'],
                     keeper['std-correction'],
                     bounds_error=False,
                     fill_value=np.nan)

        cor[:, ix] = f(corl)

    cs = np.nanmean(cor, 1)
    ccs = chebfit(corl, cs, 6)

    cor = [{"nm": corl, "cor": cs, "coeff": ccs}]
    np.save(outname, cor)
Beispiel #13
0
    def test_recursivechebyshevfunction(self):
        '''Test routines to compute using Chebyshev polynomials
        recursively.'''
        from scipy.linalg import funm
        from numpy.polynomial.chebyshev import chebfit, chebval
        from numpy import exp, linspace
        # Starting Matrix
        matrix1 = self.create_matrix(scaled=True)
        self.write_matrix(matrix1, self.input_file)

        # Function
        x = linspace(-1.0, 1.0, 200)
        y = [exp(i) for i in x]
        coef = chebfit(x, y, 16 - 1)

        # Check Matrix
        dense_check = funm(matrix1.todense(), lambda x: chebval(x, coef))
        self.CheckMat = csr_matrix(dense_check)

        # Result Matrix
        input_matrix = nt.Matrix_ps(self.input_file, False)
        poly_matrix = nt.Matrix_ps(self.mat_dim)

        polynomial = nt.ChebyshevPolynomial(len(coef))
        for j in range(0, len(coef)):
            polynomial.SetCoefficient(j, coef[j])

        permutation = nt.Permutation(input_matrix.GetLogicalDimension())
        permutation.SetRandomPermutation()
        self.fsp.SetLoadBalance(permutation)
        polynomial.ComputeFactorized(input_matrix, poly_matrix, self.fsp)
        poly_matrix.WriteToMatrixMarket(result_file)
        comm.barrier()

        self.check_result()
    def Create(x, y, itm_mask, degree):
        # filter out-of-money paths
        x_filtered = list(itertools.compress(x, itm_mask))
        y_filtered = list(itertools.compress(y, itm_mask))

        interpolator = ChebyshevInterpolator(
            chebyshev.chebfit(x_filtered, y_filtered, degree))
        return interpolator
Beispiel #15
0
def get_coff(hull, degs):

    dist_degs = np.array(compute_dist(degs, hull))

    dist_len = np.sqrt(dist_degs[:, 0]**2 + dist_degs[:, 1]**2)

    coefficient, Res = chebyshev.chebfit(degs, dist_len, 8, full=True)
    return coefficient
Beispiel #16
0
    def polynomial_max_like(self):
        order = int(self.param["order"])
        ratio = self.y_model / self.y
        errs = np.abs(self.y_err * self.y_model / self.y**2)
        coefs = chebfit(self.x, ratio, order, w=1. / errs)

        self.poly_coefs = np.array(coefs)
        self.model = chebval(self.x, coefs)
Beispiel #17
0
def main1():
    days, fuel_mass, uglovi, snaga = pop_init()
    print(days)
    koeficijenti = chebfit(x_osa(broj_segmenata), uglovi.T, podaci.chebdeg).T
    # print(uglovi, snaga)
    pop_bit = float_to_bit(days, fuel_mass, koeficijenti, snaga)
    days2, fuel_mass2, uglovi2, snaga2 = bit_to_float(pop_bit)
    print(days2 - days)
Beispiel #18
0
def getCont(wave, flam, ss=21.):
    """Fits and returns continuum"""
    cont = maximum_filter(savgol_filter(flam, 5, 2, mode='interp'), ss)
    chebx = wave - wave.min()
    chebx *= 2. / chebx.max()
    chebx -= 1.
    contfit = chebfit(chebx, cont, 6)
    cont = chebval(chebx, contfit)
    return cont
def spline_interpolation(pointx,
                         pointy,
                         wave,
                         wave_temp,
                         flux,
                         flux_temp,
                         chebfitval,
                         linewidth=2.0,
                         endpoints='y',
                         endpoint_order=4):
    """Sort spline points and interpolate between marked continuum points"""
    from numpy.polynomial import chebyshev
    from scipy.interpolate import splrep, splev

    # Insert endpoints
    if endpoints == "y" or endpoints == "t":
        sort_array = np.argsort(pointx)
        x = np.array(pointx)[sort_array]
        y = np.array(pointy)[sort_array]
        chebfit = chebyshev.chebfit(x, y, deg=endpoint_order)
        chebfitval = chebyshev.chebval(wave, chebfit)
        i = wave[150], wave[-150]
        window1, window2 = ((i[0] - 70) <= wave) & (wave <= (i[0] + 70)), (
            (i[1] - 70) <= wave) & (wave <= (i[1] + 70))
        y_val = np.median(chebfitval[window1]).astype(np.float64), np.median(
            chebfitval[window2]).astype(np.float64)
        pointx = np.concatenate([pointx, i])
        pointy = np.concatenate([pointy, y_val])
        ind_uni = f8(pointx)
        pointx = np.array(pointx)[ind_uni]
        pointy = np.array(pointy)[ind_uni]

    # Sort numerically
    # print(pointx)
    sort_array = np.argsort(pointx)
    # print(sort_array, pointx)
    # x, y = pointx[sort_array], pointy[sort_array]
    x = np.array(pointx)[sort_array]
    y = np.array(pointy)[sort_array]
    # Interpolate
    spline = splrep(x, y, k=3)

    def tap(s, x_temp):
        # offset wavelength array to ensure that wavelength does not become negative in the mirror
        diff = max(x_temp) - min(x_temp)
        k = np.tanh((x_temp - min(x_temp)) / (diff / 10.0))
        return k

    if endpoints == "t":
        continuum = splev(wave, spline) * (tap(10, wave)) * (tap(
            10, 2 * np.mean(wave) -
            wave)) + chebfitval * (1 - tap(10, wave)) + chebfitval * (
                1 - tap(10, 2 * np.mean(wave) - wave))
    else:
        continuum = splev(wave, spline)

    return continuum
Beispiel #20
0
def cheby_newton_root(z, f, z0=None, degree=512):
    import numpy.polynomial.chebyshev as npcheb
    import scipy.optimize as scpop

    Lz = np.max(z) - np.min(z)
    if z0 is None:
        z0 = Lz / 2

    def to_x(z, Lz):
        # convert back to [-1,1]
        return (2 / Lz) * z - 1

    def to_z(x, Lz):
        # convert back from [-1,1]
        return (x + 1) * Lz / 2

    logger.info("searching for roots starting from z={}".format(z0))
    x = to_x(z, Lz)
    x0 = to_x(z0, Lz)
    cheb_coeffs = npcheb.chebfit(x, f, degree)
    cheb_interp = npcheb.Chebyshev(cheb_coeffs)
    cheb_der = npcheb.chebder(cheb_coeffs)

    def newton_func(x_newton):
        return npcheb.chebval(x_newton, cheb_coeffs)

    def newton_derivative_func(x_newton):
        return npcheb.chebval(x_newton, cheb_der)

    try:
        x_root = scpop.newton(newton_func,
                              x0,
                              fprime=newton_derivative_func,
                              tol=1e-10)
        z_root = to_z(x_root, Lz)
    except:
        logger.info("error in root find")
        x_root = np.nan
        z_root = np.nan

    logger.info("newton: found root z={} (x0:{} -> {})".format(
        z_root, x0, x_root))

    for x0 in x:
        print(x0, newton_func(x0))
    a = Lz / 4
    b = Lz * 3 / 4
    logger.info("bisecting between z=[{},{}] (x=[{},{}])".format(
        a, b, to_x(a, Lz), to_x(b, Lz)))
    logger.info("f(a) = {}  and f(b) = {}".format(newton_func(to_x(a, Lz)),
                                                  newton_func(to_x(b, Lz))))
    x_root_2 = scpop.bisect(newton_func, to_x(a, Lz), to_x(b, Lz))
    z_root_2 = to_z(x_root_2, Lz)
    logger.info("bisect: found root z={} (x={})".format(z_root_2, x_root_2))

    return z_root_2
Beispiel #21
0
    def to_coefficients(self, f):
        from numpy.polynomial.chebyshev import chebfit
        import numpy as np

        # Convert infinite grid to xg = [-1, 1]
        xg = self.zg / np.sqrt(self.C ** 2 + self.zg ** 2)

        # Get coefficients for standard Chebyshev polynomials
        c, res = chebfit(xg, f, deg=self.N, full=True)

        return c
Beispiel #22
0
def spline_interpolation(pointx, pointy, wave, wave_temp, flux, flux_temp, axis,
                         leg_instance, con_instance, linewidth= 2.0, endpoints = 'y',
                         endpoint_order = 4):
    """Sort spline points and interpolate between marked continuum points"""
    from numpy.polynomial import chebyshev
    from scipy.interpolate import splrep,splev    
    
    #Insert endpoints
    if endpoints == 'y':
        sort_array = np.argsort(pointx)
        x = np.array(pointx)[sort_array]
        y = np.array(pointy)[sort_array]
        chebfit = chebyshev.chebfit(x, y, deg = endpoint_order)
        chebfitval = chebyshev.chebval(wave, chebfit)
        i =wave[150], wave[-150]
        window1, window2 = ((i[0]-70)<=wave) & (wave<=(i[0]+70)), ((i[1]-70)<=wave) & (wave<=(i[1]+70))
        y_val = np.median(chebfitval[window1]).astype(np.float64),np.median(chebfitval[window2]).astype(np.float64)
        pointx = np.concatenate([pointx,i])
        pointy = np.concatenate([pointy,y_val])
        ind_uni = f8(pointx)
        pointx = np.array(pointx)[ind_uni]
        pointy = np.array(pointy)[ind_uni]
        try:
            leg_instance.remove()
        except AttributeError:
            pass
        finally:
               leg_instance, = axis.plot(wave, chebfitval, color='black', lw = linewidth,
                                         label = 'legendre fit', zorder = 10)


    # print(pointx,pointy)
    #Sort numerically
    sort_array = np.argsort(pointx)
    x = np.array(pointx)[sort_array]
    y = np.array(pointy)[sort_array]


    from gen_methods import smooth
    #Interpolate
    spline = splrep(x,y, k=3)
    continuum = splev(wave,spline)
    continuum = smooth(continuum, window_len=1, window='hanning')
    
    #Plot
    try:
        con_instance.remove()
    except AttributeError:
        pass
    finally:
           con_instance, = axis.plot(wave,continuum, color='red', lw = linewidth, 
                                     label = 'continuum', zorder = 10)  
                                     
    return continuum, leg_instance, con_instance
Beispiel #23
0
    def to_coefficients(self, f):
        from numpy.polynomial.chebyshev import chebfit
        import numpy as np

        # Convert grid to standard xg = [-1, 1]
        xg = (self.zg - self.zmin) / self.L * 2. - 1.

        # Get coefficients for standard Chebyshev polynomials
        c, res = chebfit(xg, f, deg=self.N, full=True)

        return c
Beispiel #24
0
    def to_coefficients(self, f):
        """Convert from grid values to coefficients"""
        from numpy.polynomial.chebyshev import chebfit

        # Convert semi-infinite grid to xg = [-1, 1]
        xg = (self.zg - self.C) / (self.zg + self.C)

        # Get coefficients for standard Chebyshev polynomials
        c, res = chebfit(xg, f, deg=self.N, full=True)

        return c
Beispiel #25
0
 def test_chebfit(self) :
     def f(x) :
         return x*(x - 1)*(x - 2)
     # Test exceptions
     assert_raises(ValueError, ch.chebfit, [1],    [1],     -1)
     assert_raises(TypeError,  ch.chebfit, [[1]],  [1],      0)
     assert_raises(TypeError,  ch.chebfit, [],     [1],      0)
     assert_raises(TypeError,  ch.chebfit, [1],    [[[1]]],  0)
     assert_raises(TypeError,  ch.chebfit, [1, 2], [1],      0)
     assert_raises(TypeError,  ch.chebfit, [1],    [1, 2],   0)
     # Test fit
     x = np.linspace(0,2)
     y = f(x)
     coef = ch.chebfit(x, y, 3)
     assert_equal(len(coef), 4)
     assert_almost_equal(ch.chebval(x, coef), y)
     coef = ch.chebfit(x, y, 4)
     assert_equal(len(coef), 5)
     assert_almost_equal(ch.chebval(x, coef), y)
     coef2d = ch.chebfit(x, np.array([y,y]).T, 4)
     assert_almost_equal(coef2d, np.array([coef,coef]).T)
Beispiel #26
0
    def test_chebfit(self):
        def f(x):
            return x * (x - 1) * (x - 2)

        # Test exceptions
        assert_raises(ValueError, ch.chebfit, [1], [1], -1)
        assert_raises(TypeError, ch.chebfit, [[1]], [1], 0)
        assert_raises(TypeError, ch.chebfit, [], [1], 0)
        assert_raises(TypeError, ch.chebfit, [1], [[[1]]], 0)
        assert_raises(TypeError, ch.chebfit, [1, 2], [1], 0)
        assert_raises(TypeError, ch.chebfit, [1], [1, 2], 0)
        # Test fit
        x = np.linspace(0, 2)
        y = f(x)
        coef = ch.chebfit(x, y, 3)
        assert_equal(len(coef), 4)
        assert_almost_equal(ch.chebval(x, coef), y)
        coef = ch.chebfit(x, y, 4)
        assert_equal(len(coef), 5)
        assert_almost_equal(ch.chebval(x, coef), y)
        coef2d = ch.chebfit(x, np.array([y, y]).T, 4)
        assert_almost_equal(coef2d, np.array([coef, coef]).T)
Beispiel #27
0
def fit_range(R, T, calrange, redo_lims=True):
    # try binning in T to estimate noise for each point
    inds = np.where((T < calrange.upper) & (T > calrange.lower))
    Z = np.log10(R[inds])
    if redo_lims:
        ZL = np.min(Z)
        ZU = np.max(Z)
    else:
        ZL = calrange.ZL
        ZU = calrange.ZU
    x = ((Z - ZL) - (ZU - Z)) / (ZU - ZL)
    w = get_weights(x, T[inds])
    return x, cheby.chebfit(x, T[inds], calrange.order, w=w)
Beispiel #28
0
    def test_chebfit(self):
        def f(x):
            return x * (x - 1) * (x - 2)

        # Test exceptions
        assert_raises(ValueError, ch.chebfit, [1], [1], -1)
        assert_raises(TypeError, ch.chebfit, [[1]], [1], 0)
        assert_raises(TypeError, ch.chebfit, [], [1], 0)
        assert_raises(TypeError, ch.chebfit, [1], [[[1]]], 0)
        assert_raises(TypeError, ch.chebfit, [1, 2], [1], 0)
        assert_raises(TypeError, ch.chebfit, [1], [1, 2], 0)
        assert_raises(TypeError, ch.chebfit, [1], [1], 0, w=[[1]])
        assert_raises(TypeError, ch.chebfit, [1], [1], 0, w=[1, 1])

        # Test fit
        x = np.linspace(0, 2)
        y = f(x)
        #
        coef3 = ch.chebfit(x, y, 3)
        assert_equal(len(coef3), 4)
        assert_almost_equal(ch.chebval(x, coef3), y)
        #
        coef4 = ch.chebfit(x, y, 4)
        assert_equal(len(coef4), 5)
        assert_almost_equal(ch.chebval(x, coef4), y)
        #
        coef2d = ch.chebfit(x, np.array([y, y]).T, 3)
        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
        # test weighting
        w = np.zeros_like(x)
        yw = y.copy()
        w[1::2] = 1
        y[0::2] = 0
        wcoef3 = ch.chebfit(x, yw, 3, w=w)
        assert_almost_equal(wcoef3, coef3)
        #
        wcoef2d = ch.chebfit(x, np.array([yw, yw]).T, 3, w=w)
        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
Beispiel #29
0
    def test_chebfit(self) :
        def f(x) :
            return x*(x - 1)*(x - 2)

        # Test exceptions
        assert_raises(ValueError, cheb.chebfit, [1],    [1],     -1)
        assert_raises(TypeError,  cheb.chebfit, [[1]],  [1],      0)
        assert_raises(TypeError,  cheb.chebfit, [],     [1],      0)
        assert_raises(TypeError,  cheb.chebfit, [1],    [[[1]]],  0)
        assert_raises(TypeError,  cheb.chebfit, [1, 2], [1],      0)
        assert_raises(TypeError,  cheb.chebfit, [1],    [1, 2],   0)
        assert_raises(TypeError,  cheb.chebfit, [1],    [1],   0, w=[[1]])
        assert_raises(TypeError,  cheb.chebfit, [1],    [1],   0, w=[1,1])

        # Test fit
        x = np.linspace(0,2)
        y = f(x)
        #
        coef3 = cheb.chebfit(x, y, 3)
        assert_equal(len(coef3), 4)
        assert_almost_equal(cheb.chebval(x, coef3), y)
        #
        coef4 = cheb.chebfit(x, y, 4)
        assert_equal(len(coef4), 5)
        assert_almost_equal(cheb.chebval(x, coef4), y)
        #
        coef2d = cheb.chebfit(x, np.array([y,y]).T, 3)
        assert_almost_equal(coef2d, np.array([coef3,coef3]).T)
        # test weighting
        w = np.zeros_like(x)
        yw = y.copy()
        w[1::2] = 1
        y[0::2] = 0
        wcoef3 = cheb.chebfit(x, yw, 3, w=w)
        assert_almost_equal(wcoef3, coef3)
        #
        wcoef2d = cheb.chebfit(x, np.array([yw,yw]).T, 3, w=w)
        assert_almost_equal(wcoef2d, np.array([coef3,coef3]).T)
Beispiel #30
0
def find_func(x, yreal):
    import numpy as np
    from numpy.polynomial.chebyshev import chebfit, chebval

    f = np.polyfit(x, yreal, len(yreal))
    c = chebfit(x, yreal, len(yreal))

    ytest_poly = [round(np.polyval(f, xi), 3) for xi in x]
    ytest_cheb = [round(chebval(xi, c), 3) for xi in x]

    ytest = ytest_poly
    function_coeff = f

    return ytest, function_coeff
Beispiel #31
0
def main():
    warnings.filterwarnings("error", category=RuntimeWarning)
    comm = MPI.COMM_WORLD
    rank = comm.Get_rank()
    n = comm.Get_size()
    pop_elita = None
    if rank == 0:
        days, fuel_mass, uglovi, snaga = pop_init()
        pop_fit = np.empty(broj_jedinki)
        koeficijenti = np.empty((broj_jedinki, podaci.chebdeg + 1))
        for i in range(broj_gen):
            for j in range(broj_jedinki):
                proc_id = comm.recv(source=MPI.ANY_SOURCE, tag=1)
                comm.send(
                    (j, days[j], fuel_mass[j], uglovi[j], snaga[j], y_max),
                    dest=proc_id)
            waiting = n
            while waiting > 0:
                data = comm.recv(source=MPI.ANY_SOURCE, tag=2)
                (j, r_, _, _, min_dist_dest) = data
                pop_fit[j] = fitnes(min_dist_dest)
                koeficijenti[j] = chebfit(x_osa(broj_segmenata), uglovi[j],
                                          podaci.chebdeg)
                waiting = waiting - 1
            pop_bit = float_to_bit(days[:, np.newaxis], fuel_mass,
                                   koeficijenti, snaga, pop_fit)
            # print(pop_bit)
            pop_bit_new, pop_elita = genetski_algoritam.genetski_algoritam(
                pop_bit, pop_elita, podaci.p_elit, podaci.p_mut)
            days, fuel_mass, uglovi, snaga = bit_to_float(pop_bit_new)
            for it in range(broj_jedinki):
                days[it] = days[it] % max_time_span
            if i % 10 == 0:
                np.savetxt('gen_' + str(i) + '.txt', pop_bit_new, fmt='%d')
        for i in range(1, n):
            proc_id = comm.recv(source=MPI.ANY_SOURCE)
            comm.send(-1, dest=proc_id)
    else:
        while True:
            comm.send(comm.Get_rank(), dest=0, tag=1)
            data = comm.recv(source=0)
            if data != -1:
                _r, _v, _step, min_dist_dest = simulacija_pogon.simulacija(
                    data[1], data[2], data[3], data[4], data[5])
                comm.send((data[0], _r, _v, _step, min_dist_dest),
                          dest=0,
                          tag=2)
            else:
                print('Proc ' + str(comm.Get_rank()) + ' logs out')
                break
Beispiel #32
0
    def interpCby(self, x_in, t_in, deg=20):
        # print("t_in",t_in)
        # print("x_in",x_in)

        self.timeb = [t_in.min(), t_in.max()]
        self.chebdeg = deg

        x_in = np.transpose(x_in)
        t_fit = t_in - self.timeb[0]

        cheb_coef = cheby.chebfit(x=t_fit, y=x_in, deg=deg, full=False)
        # print(cheby.chebfit(x=t_in,y=x_in,deg=deg,full=True))
        # print("cheb_coef",cheb_coef)
        # cheb_coef = cheb_coef[0]
        self.cheb = cheb_coef
Beispiel #33
0
def cheby_fit(contours, num_coefs):
    coefs, r_maxs = [], []
    for contour in contours:
        contour = np.array(contour)
        theta = np.linspace(-1, 1, 360, endpoint=False)
        r = contour[:, 1]
        r_max = np.max(r)
        r = r / r_max
        coef, res = chebyshev.chebfit(theta, r, num_coefs, full=True)
        coefs.append(coef)
        r_maxs.append(r_max)
    coefs = np.array(coefs)
    r_maxs = np.array(r_maxs)
    cheby_coef = np.hstack((coefs, r_maxs[:, np.newaxis]))
    return cheby_coef
Beispiel #34
0
def continuum_fit(wl, flux, fluxerr, edge_mask_len=50):
    """
    Small function to estimate continuum. Takes spectrum and uses only the edges, as specified by edge_mask_len, fits
    a polynomial and returns the fit.
    :param wl: Wavelenght array in which to estimate continuum
    :param flux: Corresponding flux array
    :param fluxerr: Corresponding array containing flux errors
    :param edge_mask_len: Size of edges to use to interpolate continuum
    :return: Interpolated continuum
    """
    from numpy.polynomial import chebyshev
    wl_chebfit = np.hstack((wl[:edge_mask_len],wl[-edge_mask_len:]))
    mask_cont = np.array([i for i,n in enumerate(wl) if n in wl_chebfit])
    chebfit = chebyshev.chebfit(wl_chebfit, flux[mask_cont], deg = 1, w=1/fluxerr[mask_cont]**2)
    chebfitval = chebyshev.chebval(wl, chebfit)
    return chebfitval, chebfit
def th_plot(data, tt):
    fields = 'concurence', 'iops_mediana', 'lat_mediana'
    conc_4k = filter_data('concurrence_test_' + tt, fields, blocksize='4k')
    filtered_data = sorted(list(conc_4k(data)))

    x, iops, lat = zip(*filtered_data)

    _, ax1 = plt.subplots()

    xnew = np.linspace(min(x), max(x), 50)
    # plt.plot(xnew, power_smooth, 'b-', label='iops')
    ax1.plot(x, iops, 'b*')

    for degree in (3,):
        c = chebfit(x, iops, degree)
        vals = chebval(xnew, c)
        ax1.plot(xnew, vals, 'g--')
def th_plot(data, tt):
    fields = 'concurence', 'iops_mediana', 'lat_mediana'
    conc_4k = filter_data('concurrence_test_' + tt, fields, blocksize='4k')
    filtered_data = sorted(list(conc_4k(data)))

    x, iops, lat = zip(*filtered_data)

    _, ax1 = plt.subplots()

    xnew = np.linspace(min(x), max(x), 50)
    # plt.plot(xnew, power_smooth, 'b-', label='iops')
    ax1.plot(x, iops, 'b*')

    for degree in (3, ):
        c = chebfit(x, iops, degree)
        vals = chebval(xnew, c)
        ax1.plot(xnew, vals, 'g--')
Beispiel #37
0
def chebForwardTransform(orders, locations, functionVals):
    if len(locations.shape) == 1:
        return np.array(cheb.chebfit(locations, functionVals, orders[0]))
    else:
        if locations.shape[1] == 2:
            V = cheb.chebvander2d(locations[:, 0], locations[:, 1], orders)
        elif locations.shape[1] == 3:
            V = cheb.chebvander3d(locations[:, 0], locations[:, 1],
                                  locations[:, 2], orders)
        elif locations.shape[1] == 4:
            V = chebVander4d(locations, orders)
        elif locations.shape[1] == 5:
            V = chebVander5d(locations, orders)
        else:
            raise NotImplementedError  # there's a bad startup joke about this being good enough for the paper.
        ret, _, _, _ = npl.lstsq(V, functionVals, rcond=None)
        return np.reshape(ret, (np.array(orders) + 1).flatten())
Beispiel #38
0
def handle_A(A, fine, outname=None, standard=None, corrfile=None,
    Aoffset=None, radius=2, flat_corrections=None, nosky=False,
    lmin=650, lmax=700):
    '''Loads 2k x 2k IFU frame "A" and extracts spectra from the locations
    in "fine".

    Args:
        A (string): filename of ifu FITS file to extract from.
        fine (string): filename of NumPy file with locations + wavelength
            soln
        outname (string): filename to write results to
        Aoffset (2tuple): X (nm)/Y (pix) shift to apply for flexure correction
        radius (float): Extraction radius in arcsecond
        flat_corrections (list): A list of FlatCorrection objects for
            correcting the extraction
        nosky (Boolean): if True don't subtract sky, merely sum in aperture

    Returns:
        The extracted spectrum, a dictionary:
        {'ph_10m_nm': Flux in photon / 10 m / nanometer integrated
        'nm': Wavelength solution in nm
        'N_spax': Total number of spaxels that created ph_10m_nm
        'skyph': Sky flux in photon / 10 m / nanometer / spaxel
        'radius_as': Extraction radius in arcsec
        'pos': X/Y extraction location of spectrum in arcsec}

    Raises:
        None
    '''

    fine = np.load(fine)
    if outname is None:
        outname = "%s" % (A)

    if Aoffset is not None:
        ff = np.load(Aoffset)
        flexure_x_corr_nm = ff[0]['dXnm']
        flexure_y_corr_pix = ff[0]['dYpix']

        print "Dx %2.1f nm | Dy %2.1f px" % (ff[0]['dXnm'], ff[0]['dYpix'])
    else:
        flexure_x_corr_nm = 0
        flexure_y_corr_pix = 0

    if os.path.isfile(outname+".npy"):
        print "USING extractions in %s.npy!" % outname
        print "rm %s.npy # if you want to recreate extractions" % outname
        E, meta = np.load(outname+".npy")
        E_var, meta_var = np.load("var_" + outname + ".npy")
    else:
        print "\nCREATING extractions ..."
        spec = pf.open(A)

        adcspeed = spec[0].header["ADCSPEED"]
        if adcspeed == 2: read_var = 22*22
        else: read_var = 5*5

        var = addcon(A, str(read_var), "var_" + outname + ".fits")

        print "\nExtracting object spectra"
        E, meta = Wavelength.wavelength_extract(spec, fine, filename=outname,
            flexure_x_corr_nm=flexure_x_corr_nm,
            flexure_y_corr_pix=flexure_y_corr_pix,
            flat_corrections = flat_corrections)
        meta['airmass'] = spec[0].header['airmass']
        header = {}
        for k,v in spec[0].header.iteritems():
            try: header[k] = v
            except: pass
        meta['HA'] = spec[0].header['HA']
        meta['Dec'] = spec[0].header['Dec']
        meta['RA'] = spec[0].header['RA']
        meta['PRLLTC'] = spec[0].header['PRLLTC']
        meta['equinox'] = spec[0].header['Equinox']
        meta['utc'] = spec[0].header['utc']

        meta['header'] = header

        meta['exptime'] = spec[0].header['exptime']
        np.save(outname, [E, meta])

        print "\nExtracting variance spectra"
        E_var, meta_var = Wavelength.wavelength_extract(var, fine,
            filename=outname,
            flexure_x_corr_nm = flexure_x_corr_nm,
            flexure_y_corr_pix = flexure_y_corr_pix,
            flat_corrections=flat_corrections)

        np.save("var_" + outname, [E_var, meta_var])

    object = meta['header']['OBJECT'].split()[0]

    sixA, posA, adcpos, radius_used = identify_spectra_gui(E, radius=radius,
        PRLLTC=Angle(meta['PRLLTC'], unit='deg'),
        lmin=lmin, lmax=lmax, object=object, airmass=meta['airmass'])

    to_image(E, meta, outname, posA=posA, adcpos=adcpos)

    if standard is None:
        kixA = identify_bgd_spectra(E, posA, inner=radius_used*1.1)
    else:
        kixA = identify_sky_spectra(E, posA, inner=radius_used*1.1)

    # get the mean spectrum over the selected spaxels
    resA = interp_spectra(E, sixA, outname=outname+".pdf", corrfile=corrfile)
    skyA = interp_spectra(E, kixA, outname=outname+"_sky.pdf", corrfile=corrfile)
    varA = interp_spectra(E_var, sixA, outname=outname+"_var.pdf", corrfile=corrfile)

    ## Plot out the X/Y positions of the selected spaxels
    XSA = []
    YSA = []
    XSK = []
    YSK = []
    for ix in sixA:
        XSA.append(E[ix].X_as)
        YSA.append(E[ix].Y_as)
    for ix in kixA:
        XSK.append(E[ix].X_as)
        YSK.append(E[ix].Y_as)

    pl.figure()
    pl.clf()
    pl.ylim(-30,30)
    pl.xlim(-30,30)
    pl.scatter(XSA,YSA, color='red', marker='H', linewidth=.1)
    pl.scatter(XSK,YSK, color='green', marker='H', linewidth=.1)
    pl.savefig("XYs_%s.pdf" % outname)
    pl.close()
    # / End Plot

    # Define our standard wavelength grid
    ll = Wavelength.fiducial_spectrum()

    # Resample sky onto standard wavelength grid
    sky_A = interp1d(skyA[0]['nm'], skyA[0]['ph_10m_nm'], bounds_error=False)
    sky = sky_A(ll)

    # Resample variance onto standard wavelength grid
    var_A = interp1d(varA[0]['nm'], varA[0]['ph_10m_nm'], bounds_error=False)
    varspec = var_A(ll)

    # Copy and resample object spectrum onto standard wavelength grid
    res = np.copy(resA)
    res = [{"doc": resA[0]["doc"], "ph_10m_nm": np.copy(resA[0]["ph_10m_nm"]),
        "spectra": np.copy(resA[0]["spectra"]),
        "coefficients": np.copy(resA[0]["coefficients"]),
        "nm": np.copy(resA[0]["ph_10m_nm"])}]
    res[0]['nm'] = np.copy(ll)
    f1 = interp1d(resA[0]['nm'], resA[0]['ph_10m_nm'], bounds_error=False)

    # Calculate airmass correction
    airmass = meta['airmass']

    extCorr = 10**(Atm.ext(ll*10) * airmass/2.5)
    print "Median airmass corr: %.4f" % np.median(extCorr)

    # Calculate output corrected spectrum
    if nosky:
        # Account for airmass and aperture
        res[0]['ph_10m_nm'] = f1(ll) * extCorr * len(sixA)
    else:
        # Account for sky, airmass and aperture
        res[0]['ph_10m_nm'] = (f1(ll)-sky_A(ll)) * extCorr * len(sixA)

    # Process standard star objects
    if standard is not None:
        print "STANDARD"

        # Extract reference data
        wav = standard[:,0]/10.0
        flux = standard[:,1]

        # Calculate/Interpolate correction onto object wavelengths
        fun = interp1d(wav, flux, bounds_error=False, fill_value = np.nan)
        correction0 = fun(res[0]['nm'])/res[0]['ph_10m_nm']

        # Filter for resolution
        flxf = filters.gaussian_filter(flux,19.)

        # Calculate/Interpolate filtered correction
        fun = interp1d(wav, flxf, bounds_error=False, fill_value = np.nan)
        correction = fun(res[0]['nm'])/res[0]['ph_10m_nm']

        # Use unfiltered for H-beta region
        ROI = (res[0]['nm'] > 470.) & (res[0]['nm'] < 600.)
        correction[ROI] = correction0[ROI]

        res[0]['std-correction'] = correction
        res[0]['std-maxnm'] = np.max(wav)


    res[0]['exptime'] = meta['exptime']
    res[0]['Extinction Correction'] = 'Applied using Hayes & Latham'
    res[0]['extinction_corr'] = extCorr
    res[0]['skyph'] = sky * len(sixA)
    res[0]['skynm'] = ll
    res[0]['var'] = varspec
    res[0]['radius_as'] = radius_used
    res[0]['position'] = posA
    res[0]['N_spax'] = len(sixA)
    res[0]['meta'] = meta
    res[0]['object_spaxel_ids'] = sixA
    res[0]['sky_spaxel_ids'] = kixA
    res[0]['sky_spectra'] = skyA[0]['spectra']

    coef = chebfit(np.arange(len(ll)), ll, 4)
    xs = np.arange(len(ll)+1)
    newll = chebval(xs, coef)

    res[0]['dlam'] = np.diff(newll)

    np.save("sp_" + outname, res)
    print "Wrote sp_"+outname+".npy"
start=0
for i, index in enumerate(index_ranges):

        #Where the telluric features are
        t_start=int(index[0][0])
        t_end=int(index[1][0])



        #Get the indices away from the telluric features
        end=t_start

        #Rescale lamda array to be between -1 and 1
        l=np.array([2*(w-lamdas[start:end].min())/(lamdas[start:end].max()-lamdas[start:end].min())-1 for w in lamdas[start:end]])

        polyfit=chebfit(l, spec[start:end], order)
        polynomial=chebval(l, polyfit)

        print("Fitting Polynomials from lamda={}A to lamda={}A".format(lamdas[start], lamdas[end]))
        fit_spec[start:end]=polynomial
        fit_spec_no_smooth[start:end]=polynomial
        fit_spec[start:start+pixels]=start_blend(start, pixels, fit_spec, spec)
        fit_spec[end-pixels:end]=end_blend(end, pixels, fit_spec, spec)


        #Update the start value for the next section of the spectrum to fit
        start=t_end

#Do the last section of the fit
s=index_ranges[-1][1][0]
#Rescale the wavelength array to be between -1 and 1.
def wavelegth_fitter(wavelength_fits, cube, var, aperture_mask, lamdas, order, aperture_indices, plot=False, verbose=False):

    """
    Fit polynomials in the wavelength direction of each pixel in an aperture. This makes the P(x,lamda) values used in Horne 1986
    Returns a cube of model values, called mcube

    Wavelength_fits is an cube of un-normalised values, initially all 0s
    cube is the datacube in question
    var is the variance cube
    aperture mask is a 3D mask of True and False. Good values=True, Bad ones =False
    lamdas is an array of lamda values along the wavelength axis, formed from CRPIX,CRVAL,CDELT in the fits header
    order is the order of fitting
    aperture indices are indices of the cube corresponding to our circular aperture, in an Nx2 array. This is looped over.
    plot=True shows a plot of the polynomials (both before and after normalising spatially)
    verbose=True prints more to the terminal

    """

    #Lamdas must be scaled to between -1 and 1 for Chebyshev fitting
    min_val=lamdas.min()
    max_val=lamdas.max()
    scaled_l=np.array([2*(lamda-min_val)/(max_val-min_val) -1 for lamda in lamdas])

    for n, (i, j) in enumerate(zip(aperture_indices[0], aperture_indices[1])):

        """Take each spaxel and fit a polynomial along the wavelength direction, each pixel weighted by one over its variance"""
        if verbose==True:
            print("Fitting Pixel {}".format(n))

        weights=1.0/var[:, i, j]

        #Fit the Chebyshev coefficients
        coefficients=chebfit(scaled_l, cube[:, i, j], order, w=weights)

        #Make a polynomial from these
        polynomial=chebval(scaled_l, coefficients)
        #Ensure all values are positve
        polynomial[polynomial<0]=0


        wavelength_fits[:, i, j]=polynomial

    if plot==True:
        for i, j in zip(aperture_indices[0], aperture_indices[1]):
            plt.plot(lamdas, wavelength_fits[:, :])

        plt.show()

    if verbose==True:
        print("Normalising Spatially")
    #Normalise spatially
    spatial_norm=np.sum(np.sum(wavelength_fits, axis=2), axis=1)
    mcube=wavelength_fits/spatial_norm[:, np.newaxis, np.newaxis]



    if plot==True:
        for i, j in zip(aperture_indices[0], aperture_indices[1]):

            plt.plot(lamdas, mcube[:,i, j])

        plt.show()

    return mcube
Beispiel #41
0
def handle_AB(A, B, fine, outname=None, corrfile=None,
    Aoffset=None, Boffset=None, radius=2, flat_corrections=None,
    nosky=False, lmin=650, lmax=700):
    '''Loads 2k x 2k IFU frame "A" and "B" and extracts A-B and A+B spectra
    from the "fine" location. 

    Args:
        A (string): filename of ifu FITS file to extract from.
        B (string): filename of ifu FITS file to extract from.
        fine (string): filename of NumPy file with locations + wavelength
            soln
        outname (string): filename to write results to
        Aoffset (2tuple): X (nm)/Y (pix) shift to apply for flexure correction
        Boffset (2tuple): X (nm)/Y (pix) shift to apply for flexure correction
        radius (float): Extraction radius in arcsecond
        flat_corrections (list): A list of FlatCorrection objects for
            correcting the extraction
	nosky (Boolean): if True don't subtract sky, merely sum in aperture

    Returns:
        The extracted spectrum, a dictionary:
        {'ph_10m_nm': Flux in photon / 10 m / nanometer integrated
        'var'
        'nm': Wavelength solution in nm
        'N_spaxA': Total number of "A" spaxels 
        'N_spaxB': Total number of "B" spaxels
        'skyph': Sky flux in photon / 10 m / nanometer / spaxel
        'radius_as': Extraction radius in arcsec
        'pos': X/Y extraction location of spectrum in arcsec}

    Raises:
        None
    '''

    fine = np.load(fine)
    if outname is None:
        outname = "%sm%s" % (A,B)

    if Aoffset is not None:
        ff = np.load(Aoffset)
        flexure_x_corr_nm = ff[0]['dXnm']
        flexure_y_corr_pix = -ff[0]['dYpix']

        print "Dx %2.1f | Dy %2.1f" % (ff[0]['dXnm'], ff[0]['dYpix'])
    else:
        flexure_x_corr_nm = 0
        flexure_y_corr_pix = 0

    read_var = 5*5
    if os.path.isfile(outname + ".fits.npy"):
        print "USING extractions in %s!" % outname
        E, meta = np.load(outname + ".fits.npy")
        E_var, meta_var = np.load("var_" + outname + ".fits.npy")
    else:
        if not outname.endswith(".fits"): 
            outname = outname + ".fits"
            diff = subtract(A,B, outname)
            add(A,B, "tmpvar_" + outname)

            adcspeed = diff[0].header["ADCSPEED"]
            if adcspeed == 2: read_var = 22*22
            else: read_var = 5*5

        var = add("tmpvar_" + outname, str(read_var), "var_" + outname)
        os.remove("tmpvar_" + outname + ".gz")


        E, meta = Wavelength.wavelength_extract(diff, fine, 
            filename=outname,
            flexure_x_corr_nm = flexure_x_corr_nm, 
            flexure_y_corr_pix = flexure_y_corr_pix,
            flat_corrections=flat_corrections)
        meta['airmass1'] = diff[0].header['airmass1']
        meta['airmass2'] = diff[0].header['airmass2']
        meta['airmass'] = diff[0].header['airmass']
        header = {}
        for k,v in diff[0].header.iteritems():
            try: header[k] = v
            except: pass
        meta['HA'] = diff[0].header['HA']
        meta['Dec'] = diff[0].header['Dec']
        meta['RA'] = diff[0].header['RA']
        meta['PRLLTC'] = diff[0].header['PRLLTC']
        meta['equinox'] = diff[0].header['Equinox']
        meta['utc'] = diff[0].header['utc']

        meta['header'] = header

        meta['exptime'] = diff[0].header['exptime']
        np.save(outname, [E, meta])

        exfile = "extracted_var_%s.npy" % outname
        E_var, meta_var = Wavelength.wavelength_extract(var, fine, 
            filename=outname,
            flexure_x_corr_nm = flexure_x_corr_nm, 
            flexure_y_corr_pix = flexure_y_corr_pix,
            flat_corrections=flat_corrections)

        np.save("var_" + outname, [E_var, meta_var])

    sixA, posA, all_A = identify_spectra_gui(E, radius=radius, 
        PRLLTC=Angle(meta['PRLLTC'], unit='deg'),
        lmin=lmin, lmax=lmax, airmass=meta['airmass'])
    sixB, posB, all_B = identify_spectra_gui(E, radius=radius,
        PRLLTC=Angle(meta['PRLLTC'], unit='deg'),
        lmin=lmin, lmax=lmax, airmass=meta['airmass'])

    to_image(E, meta, outname, posA=posA, posB=posB, adcpos=all_A)

    skyA = identify_bgd_spectra(E, posA)
    skyB = identify_bgd_spectra(E, posB)

    allix = np.concatenate([sixA, sixB])
    resA = interp_spectra(E, sixA, sign=1, outname=outname+"_A.pdf", corrfile=corrfile)
    resB = interp_spectra(E, sixB, sign=-1, outname=outname+"_B.pdf", corrfile=corrfile)
    skyA = interp_spectra(E, skyA, sign=1, outname=outname+"_skyA.pdf", corrfile=corrfile)
    skyB = interp_spectra(E, skyB, sign=-1, outname=outname+"_skYB.pdf", corrfile=corrfile)
    varA = interp_spectra(E_var, sixA, sign=1, outname=outname+"_A_var.pdf", corrfile=corrfile)
    varB = interp_spectra(E_var, sixB, sign=1, outname=outname+"_B_var.pdf", corrfile=corrfile)
    
    
    ## Plot out the X/Y selected spectra
    XSA = []
    YSA = []
    XSB = []
    YSB = []
    for ix in sixA:
        XSA.append(E[ix].X_as)
        YSA.append(E[ix].Y_as)
    for ix in sixB:
        XSB.append(E[ix].X_as)
        YSB.append(E[ix].Y_as)

    pl.figure()
    pl.clf()
    pl.ylim(-30,30)
    pl.xlim(-30,30)
    pl.scatter(XSA,YSA, color='blue', marker='H', linewidth=.1)
    pl.scatter(XSB,YSB, color='red', marker='H', linewidth=.1)
    pl.savefig("XYs_%s.pdf" % outname)
    pl.close()
    # / End Plot

    np.save("sp_A_" + outname, resA)
    np.save("sp_B_" + outname, resB)
    np.save("var_A_" + outname, varA)
    np.save("var_B_" + outname, varB)

    ll = Wavelength.fiducial_spectrum()
    sky_A = interp1d(skyA[0]['nm'], skyA[0]['ph_10m_nm'], bounds_error=False)
    sky_B = interp1d(skyB[0]['nm'], skyB[0]['ph_10m_nm'], bounds_error=False)
    sky = np.nanmean([sky_A(ll), sky_B(ll)], axis=0)

    var_A = interp1d(varA[0]['nm'], varA[0]['ph_10m_nm'], bounds_error=False)
    var_B = interp1d(varB[0]['nm'], varB[0]['ph_10m_nm'], bounds_error=False)
    varspec = np.nanmean([var_A(ll), var_B(ll)], axis=0) * (len(sixA) + len(sixB))

    res = np.copy(resA)
    res = [{"doc": resA[0]["doc"], "ph_10m_nm": np.copy(resA[0]["ph_10m_nm"]),
        "nm": np.copy(resA[0]["ph_10m_nm"])}]
    res[0]['nm'] = np.copy(ll)
    f1 = interp1d(resA[0]['nm'], resA[0]['ph_10m_nm'], bounds_error=False)
    f2 = interp1d(resB[0]['nm'], resB[0]['ph_10m_nm'], bounds_error=False)

    airmassA = meta['airmass1']
    airmassB = meta['airmass2']

    extCorrA = 10**(Atm.ext(ll*10)*airmassA/2.5)
    extCorrB = 10**(Atm.ext(ll*10)*airmassB/2.5)
    print "Median airmass corr: ", np.median(extCorrA), np.median(extCorrB)
    # If requested merely sum in aperture, otherwise subtract sky
    if nosky:
    	res[0]['ph_10m_nm'] = \
        	np.nansum([
            	f1(ll) * extCorrA, 
            	f2(ll) * extCorrB], axis=0) * \
            	(len(sixA) + len(sixB))
    else:
    	res[0]['ph_10m_nm'] = \
        	np.nansum([
            	(f1(ll)-sky_A(ll)) * extCorrA, 
            	(f2(ll)-sky_B(ll)) * extCorrB], axis=0) * \
            	(len(sixA) + len(sixB))

    res[0]['exptime'] = meta['exptime']
    res[0]['Extinction Correction'] = 'Applied using Hayes & Latham'
    res[0]['extinction_corr_A'] = extCorrA
    res[0]['extinction_corr_B'] = extCorrB
    res[0]['skyph'] = sky
    res[0]['var'] = varspec
    res[0]['radius_as'] = radius
    res[0]['positionA'] = posA
    res[0]['positionB'] = posA
    res[0]['N_spaxA'] = len(sixA)
    res[0]['N_spaxB'] = len(sixB)
    res[0]['meta'] = meta
    res[0]['object_spaxel_ids_A'] = sixA
    res[0]['sky_spaxel_ids_A'] = skyA 
    res[0]['object_spaxel_ids_B'] = sixB
    res[0]['sky_spaxel_ids_B'] = skyB

    coef = chebfit(np.arange(len(ll)), ll, 4)
    xs = np.arange(len(ll)+1)
    newll = chebval(xs, coef)

    res[0]['dlam'] = np.diff(newll)

    np.save("sp_" + outname, res)
Beispiel #42
0
def main():
    M = 3 * pow(2, 5)
    N = 15
    # good values
    a1 = np.pi / 8.
    a2 = np.pi / 4.

    alphas = np.array([i / float(M) for i in range(1, M + 3)])
    r = np.zeros((len(alphas), 2))
    err = np.zeros((len(alphas), 2))
    A1 = np.linspace(0, a1, 50)
    T1 = getTheta(A1)
    Phitrue1 = phi(T1)
    A2 = np.linspace(a1, a2, 50)
    T2 = getTheta(A2)
    Phitrue2 = phi(T2)
    x = getChebNodes(N)

    for k in range(len(alphas)):
        p = alphas[k]
        print x
        #ax1 = [np.pi/8.*pow((xi+1.)/2,1./p) for xi in x]
        ax1 = fA(x, p, 0, a1)
        ax2 = fA(x, p, a2, a1)
        #ax2 = [np.pi/8.+np.pi/8.*pow((xi+1.)/2,1./p) for xi in x]
        theta1 = getTheta(ax1)
        theta2 = getTheta(ax2)
        # print "ax2"
        #print (ax2-1./8.*(theta2-np.sin(theta2)))
        # print "Theta"
        # print theta
        #print (1./8*(theta-np.sin(theta))-ax)
        phi1 = phi(theta1)
        phi2 = phi(theta2)
        fp1 = cheb.chebfit(x, phi1, N)
        fp2 = cheb.chebfit(x, phi2, N)
        print "Chebyshev Coeffs"
        print fp2
        r[k, 0] = abs(fp1[-1])
        r[k, 1] = abs(fp2[-1])
        err[k, 0] = np.linalg.norm(
            Phitrue1 - cheb.chebval(fX(A1, p, 0, a1), fp1))
        err[k, 1] = np.linalg.norm(
            Phitrue2 - cheb.chebval(fX(A2, p, a2, a1), fp2))
    print "Nth coefficient"
    print r
    print "Error"
    print err
    # print alphas
    p1 = 1. / 3.
    p2 = 5. / 12.
    ax1 = fA(x, p1, 0., a1)
    ax2 = fA(x, p2, a2, a1)
    theta1 = getTheta(ax1)
    theta2 = getTheta(ax2)
    phi1 = phi(theta1)
    phi2 = phi(theta2)
    fp1 = cheb.chebfit(x, phi1, N)
    fp2 = cheb.chebfit(x, phi2, N)
    print fp1

    plt.rc('text', usetex=True)
    plt.rc('font', family='serif')

    plt.subplots_adjust(hspace=0.4)
    plt.subplot(211)
    plt.semilogy(alphas, r)
    plt.legend([r"$\phi_1(A)$", r"$\phi_2(A)$"])
    xlab = ['1/6', '1/4', '1/3', '5/12', '1/2', '2/3', '3/4', '5/6', '1']
    ticks = [1. / 6., 1. / 4., 1. / 3., 5. / 12.,
             1. / 2., 2. / 3., 3. / 4., 5. / 6., 1.]
    plt.xticks(ticks, xlab)
    plt.grid(True)
    plt.title(
        r'$\phi(x) \approx \tilde{\phi}(x) =\sum_k a_k T_k(cx^{\alpha}-1)$')
    plt.ylabel('coefficient decay')
    # plt.ylabel(r'a_N')
    plt.xlabel(r'$\alpha$')
    plt.subplot(212)
    plt.xlabel(r'$\alpha$')
    # plt.ylabel(r'$\phi_i(x)-\phi_i^N(x)$')
    plt.semilogy(alphas, err)
    plt.xticks(ticks, xlab)
    plt.grid(True)
    # plt.title('Error')
    plt.ylabel('Error')
    plt.legend([r"$\phi_1(A)$", r"$\phi_2(A)$"])
    f = open("blah.txt", "w")
    MM = 200
    t = np.linspace(0, 2 * np.pi, MM)
    aa = 1. / 8. * (t - np.sin(t))
    phit = phi(t)
    phit1 = cheb.chebval(fX(aa[0:MM / 2], p1, 0., a1), fp1)
    phit2 = cheb.chebval(fX(aa[MM / 2:], p2, a2, a1), fp2)
    for k in range(len(t)):
        if k < MM / 2:
            ha = phit1[k]
        else:
            ha = phit2[k - MM / 2]
        f.write("%s   %s   %s\n" % (aa[k], phit[k] - ha, ha))
    f.close()
    plt.show()
    print phi([2 * np.pi])
Beispiel #43
0
def chebfit(x, y, deg, rcond=None, full=False, w=None):
    from numpy.polynomial.chebyshev import chebfit
    return chebfit(x, y, deg, rcond, full, w)

# Get sorted element indices for x-axis variable. It is the requirement of the
# function being used for Spline Fitting that the X be in an increasing order.
# But the way the rotation curve was extracted was to stepping away from the centre
# to the outside and then back to centre and the other side. Hence the need for
# sorting the same.

sortind = np.argsort( rotcurve["Row"] )

fig1 = plt.figure(1)
xs = np.linspace( np.min(rotcurve["Row"]), np.max(rotcurve["Row"]), 1000)
residuals = []
change=0.0
for i in range(15):
	interp_coeff = chebfit( rotcurve["Row"], rotcurve["lambda"], w=1/rotcurve["lambda_err"], deg=i)
	interp_coeff_z = chebfit( rotcurve["Row"], rotcurve["z"], w=1/rotcurve["z_err"], deg=i)


	# Below, we are just generating a sample curve for the user to visualize the fit.
	ys = chebval(xs, interp_coeff)
	
	# Residual calculation in redshift space.
	predicted = chebval( rotcurve["Row"], interp_coeff_z )
	rms = np.sqrt( np.sum( (predicted - rotcurve["z"])**2 ) / len(predicted) )
	print rms
	residuals.append(rms)
	# Now, present the plot to the user.
	plt.errorbar( rotcurve["Row"], rotcurve["lambda"], rotcurve["lambda_err"], fmt="o" )
	plt.plot(xs, ys)
	plt.xlabel("Row Number", fontsize=18)
Beispiel #45
0
def main():
    pi = np.pi
    N = 20
    a1 = pi / 8.
    a2 = pi / 4.
    p1 = 1. / 3.
    p2 = 5. / 12.
    x = getChebNodes(N)
    ax1 = fA(x, p1, 0., a1)
    ax2 = fA(x, p2, a2, a1)
    theta1 = getTheta(ax1)
    theta2 = getTheta(ax2)
    phi1 = phi(theta1)
    phi2 = phi(theta2)
    fp1 = cheb.chebfit(x, phi1, N)
    fp2 = cheb.chebfit(x, phi2, N)
#	print fp1
#	print fp2
    print "Disagreement at pi/8 is %.15f" % (cheb.chebval(1, fp1) - cheb.chebval(1, fp2))
    phim1 = cheb.chebval(1, fp2)
    phim2 = cheb.chebval(-1, fp2)
#	print phim1;
#	print phim2;

    K = 4
    M = 3 * pow(2, K)
    M = 60
    K = 5
    alphas = np.array([i / float(M) for i in range(2 * K, M + 3)])
    Atrue1 = np.linspace(0, pi / 8., 200)
    Atrue2 = np.linspace(pi / 8., pi / 4., 200)
    phis1 = cheb.chebval(fX(Atrue1, p1, 0, a1), fp1)
    phis2 = cheb.chebval(fX(Atrue2, p2, a2, a1), fp2)
    #alphas = [1./3.]
#	print cheb.chebval(fX(0,p1,0,a1),fp1)
#	print cheb.chebval(fX(pi/8,p1,0,a1),fp1)-phim1
    r = np.zeros((len(alphas), 2))
    err = np.zeros((len(alphas), 2))
    for k in range(len(alphas)):
        p = alphas[k]
        sx1 = fA(x, p, 0, phim1)
        sx2 = fA(x, p, phim2, phim1)
        A1 = np.zeros(len(sx1))
        A2 = np.zeros(len(sx1))
    #	print "p = %f" %p
    #	print sx1
    #	print sx2
        for i in range(1, len(sx1) - 1):
            A1[i] = optimize.ridder(
                lambda x: -cheb.chebval(fX(x, p1, 0, a1), fp1) + sx1[i], 0, pi / 8. + .1)
        A1[-1] = pi / 8.
        A2 = [optimize.ridder(lambda x: cheb.chebval(
            fX(x, p2, a2, a1), fp2) - sxi, pi / 8., pi / 4.) for sxi in sx2]
    #	print A1
    #	print A2
        fa1 = cheb.chebfit(x, A1, N)
        fa2 = cheb.chebfit(x, A2, N)
    #	print fa1
    #	print fa2
        r[k, 0] = abs(fa1[-1])
        r[k, 1] = abs(fa2[-1])
        err[k, 0] = np.linalg.norm(
            Atrue1 - cheb.chebval(fX(phis1, p, 0, phim1), fa1))
        err[k, 1] = np.linalg.norm(
            Atrue2 - cheb.chebval(fX(phis2, p, phim2, phim1), fa2))
    print "alpha      r1      r2     err1      err2"
    for j in range(len(r)):
        print " %f   %e   %e   %e   %e" % (alphas[j], r[j, 0], r[j, 1], err[j, 0], err[j, 1])
    plt.rc('text', usetex=True)
    plt.rc('font', family='serif')

    plt.subplots_adjust(hspace=0.4)
    plt.subplot(211)
    plt.semilogy(alphas, r)
    plt.legend([r"$\phi^{-1}_1$", r"$\phi^{-1}_2$"])
    xlab = ['1/6', '1/4', '1/3', '2/5', '1/2', '3/5', '2/3', '3/4', '5/6', '1']
    ticks = [1. / 6., 1. / 4., 1. / 3., 2. / 5., 1. /
             2., 3. / 5., 2. / 3., 3. / 4., 5. / 6., 1.]
    plt.xticks(ticks, xlab)
    plt.grid(True)
    plt.title(r'$\phi^{-1}(x) \approx \sum_k a_k T_k(cx^{\alpha}-1)$')
    # plt.ylabel(r'a_N')
    plt.ylabel('coefficient decay')
    plt.xlabel(r'$\alpha$')
    plt.subplot(212)
    plt.xlabel(r'$\alpha$')
    plt.ylabel('Error')
    # plt.ylabel(r'$\phi^{-1}_i(x)-\tilde{\phi}_i^{-1}(x)$')
    plt.semilogy(alphas, err)
    plt.xticks(ticks, xlab)
    plt.grid(True)
    plt.title('Error')
    plt.legend([r"$\phi^{-1}_1$", r"$\phi^{-1}_2$"])
    # plt.show()
    p3 = 1.
    p4 = 3. / 5
    sx1 = fA(x, p3, 0, phim1)
    sx2 = fA(x, p4, phim2, phim1)
    A1 = np.zeros(len(sx1))
    A2 = np.zeros(len(sx1))
#	print sx1
#	print sx2
    for i in range(1, len(sx1) - 1):
        A1[i] = optimize.ridder(
            lambda x: -cheb.chebval(fX(x, p1, 0, a1), fp1) + sx1[i], 0, pi / 8. + .1)
    A1[-1] = pi / 8.
    A2 = [optimize.ridder(lambda x: cheb.chebval(
        fX(x, p2, a2, a1), fp2) - sxi, pi / 8., pi / 4.) for sxi in sx2]
#	print A1
#	print A2
    fa1 = cheb.chebfit(x, A1, N)
    fa2 = cheb.chebfit(x, A2, N)
#	print fa1
#	print fa2

    print "Power for phi1 is %f" % p1
    print "Power for phi2 is %f" % p2
    print "Power for phi1^(-1) is %f" % p3
    print "Power for phi2^(-1) is %f" % p4
    fnames = ["phiofA1.txt", "phiofA2.txt", "Aofphi1.txt", "Aofphi2.txt"]
    coeffs = np.zeros((N + 1, 4))
    coeffs[:, 0] = fp1
    coeffs[:, 1] = fp2
    coeffs[:, 2] = fa1
    coeffs[:, 3] = fa2
    for i in range(4):
        f = open(fnames[i], "w")
        for j in range(len(fa1)):
            f.write("%.16f, " % (coeffs[j, i]))
        f.close()
    for i in range(N + 1):
        print "%.16f,  " % x[i]
Beispiel #46
0
# For spline measurement
s_bot, s_cnt, s_fwhm, s_as12, s_fw13, s_as13, s_fw23, s_as23, s_err, s_ew, s_cont = np.arange(0, 11)

reg = __import__("6405")
flat1 = list(range(169, 184))
flat2 = list(range(913, 932))
flat3 = list(range(979, 995))
flat4 = list(range(1147, 1239))

flt1 = reg.qu1m[flat1] / reg.qu1m[flat1].mean()
flt2 = reg.qu1m[flat2] / reg.qu1m[flat2].mean()
flt3 = reg.qu1m[flat3] / reg.qu1m[flat3].mean()
flt4 = reg.qu1m[flat4] / reg.qu1m[flat4].mean()
flt = np.hstack((flt1, flt2, flt3, flt4))
pos = np.arange(0, len(flt))
chb = ch.chebfit(pos, flt, 5)  # Use for normalization later

bak1 = reg.qu1[:, flat1] / reg.qu1[:, flat1].mean(axis=1).reshape(-1, 1)
bak2 = reg.qu1[:, flat2] / reg.qu1[:, flat2].mean(axis=1).reshape(-1, 1)
bak3 = reg.qu1[:, flat3] / reg.qu1[:, flat3].mean(axis=1).reshape(-1, 1)
bak4 = reg.qu1[:, flat4] / reg.qu1[:, flat4].mean(axis=1).reshape(-1, 1)

bak = np.hstack((bak1, bak2, bak3, bak4)) / ch.chebval(pos, chb).T

width = 1420  # Magic number found by trial
bak = bak.reshape(-1, width)
blmbd = reg.qu1.lmbd[:width]
bmet = reg.qu1.meta
bmet.lmbd = blmbd
bmet.ref = None
bmet.cont = (0, np.ones(bak.shape[0]))
Beispiel #47
0
def chebyshev_fit(fit_me, xi, xf, weights,order=7, *args, **kwargs):
  chebfunc = chebyshev.chebfit(xi,fit_me,deg=order,w=weights)
  fitted = chebyshev.chebval(xf,chebfunc)
  residual = chebyshev.chebval(xi, chebfunc) - fit_me
  return (fitted, residual)
Beispiel #48
0
 def _fit_builtin(self,func,N):
     """ Return the chebyshev coefficients using the builtin chebfit """
     pts = cheb.chebpts2(N)
     y = func(pts)
     coeffs = cheb.chebfit(pts,y,N)
     return coeffs
Beispiel #49
0
    def test_chebfit(self):
        def f(x):
            return x*(x - 1)*(x - 2)

        def f2(x):
            return x**4 + x**2 + 1

        # Test exceptions
        assert_raises(ValueError, cheb.chebfit, [1], [1], -1)
        assert_raises(TypeError, cheb.chebfit, [[1]], [1], 0)
        assert_raises(TypeError, cheb.chebfit, [], [1], 0)
        assert_raises(TypeError, cheb.chebfit, [1], [[[1]]], 0)
        assert_raises(TypeError, cheb.chebfit, [1, 2], [1], 0)
        assert_raises(TypeError, cheb.chebfit, [1], [1, 2], 0)
        assert_raises(TypeError, cheb.chebfit, [1], [1], 0, w=[[1]])
        assert_raises(TypeError, cheb.chebfit, [1], [1], 0, w=[1, 1])
        assert_raises(ValueError, cheb.chebfit, [1], [1], [-1,])
        assert_raises(ValueError, cheb.chebfit, [1], [1], [2, -1, 6])
        assert_raises(TypeError, cheb.chebfit, [1], [1], [])

        # Test fit
        x = np.linspace(0, 2)
        y = f(x)
        #
        coef3 = cheb.chebfit(x, y, 3)
        assert_equal(len(coef3), 4)
        assert_almost_equal(cheb.chebval(x, coef3), y)
        coef3 = cheb.chebfit(x, y, [0, 1, 2, 3])
        assert_equal(len(coef3), 4)
        assert_almost_equal(cheb.chebval(x, coef3), y)
        #
        coef4 = cheb.chebfit(x, y, 4)
        assert_equal(len(coef4), 5)
        assert_almost_equal(cheb.chebval(x, coef4), y)
        coef4 = cheb.chebfit(x, y, [0, 1, 2, 3, 4])
        assert_equal(len(coef4), 5)
        assert_almost_equal(cheb.chebval(x, coef4), y)
        # check things still work if deg is not in strict increasing
        coef4 = cheb.chebfit(x, y, [2, 3, 4, 1, 0])
        assert_equal(len(coef4), 5)
        assert_almost_equal(cheb.chebval(x, coef4), y)
        #
        coef2d = cheb.chebfit(x, np.array([y, y]).T, 3)
        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
        coef2d = cheb.chebfit(x, np.array([y, y]).T, [0, 1, 2, 3])
        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
        # test weighting
        w = np.zeros_like(x)
        yw = y.copy()
        w[1::2] = 1
        y[0::2] = 0
        wcoef3 = cheb.chebfit(x, yw, 3, w=w)
        assert_almost_equal(wcoef3, coef3)
        wcoef3 = cheb.chebfit(x, yw, [0, 1, 2, 3], w=w)
        assert_almost_equal(wcoef3, coef3)
        #
        wcoef2d = cheb.chebfit(x, np.array([yw, yw]).T, 3, w=w)
        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
        wcoef2d = cheb.chebfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
        # test scaling with complex values x points whose square
        # is zero when summed.
        x = [1, 1j, -1, -1j]
        assert_almost_equal(cheb.chebfit(x, x, 1), [0, 1])
        assert_almost_equal(cheb.chebfit(x, x, [0, 1]), [0, 1])
        # test fitting only even polynomials
        x = np.linspace(-1, 1)
        y = f2(x)
        coef1 = cheb.chebfit(x, y, 4)
        assert_almost_equal(cheb.chebval(x, coef1), y)
        coef2 = cheb.chebfit(x, y, [0, 2, 4])
        assert_almost_equal(cheb.chebval(x, coef2), y)
        assert_almost_equal(coef1, coef2)
Beispiel #50
0
    def test_chebfit(self) :
        def f(x) :
            return x*(x - 1)*(x - 2)

        # Test exceptions
        assert_raises(ValueError, cheb.chebfit, [1],    [1],     -1)
        assert_raises(TypeError,  cheb.chebfit, [[1]],  [1],      0)
        assert_raises(TypeError,  cheb.chebfit, [],     [1],      0)
        assert_raises(TypeError,  cheb.chebfit, [1],    [[[1]]],  0)
        assert_raises(TypeError,  cheb.chebfit, [1, 2], [1],      0)
        assert_raises(TypeError,  cheb.chebfit, [1],    [1, 2],   0)
        assert_raises(TypeError,  cheb.chebfit, [1],    [1],   0, w=[[1]])
        assert_raises(TypeError,  cheb.chebfit, [1],    [1],   0, w=[1,1])

        # Test fit
        x = np.linspace(0,2)
        y = f(x)
        #
        coef3 = cheb.chebfit(x, y, 3)
        assert_equal(len(coef3), 4)
        assert_almost_equal(cheb.chebval(x, coef3), y)
        #
        coef4 = cheb.chebfit(x, y, 4)
        assert_equal(len(coef4), 5)
        assert_almost_equal(cheb.chebval(x, coef4), y)
        #
        coef2d = cheb.chebfit(x, np.array([y,y]).T, 3)
        assert_almost_equal(coef2d, np.array([coef3,coef3]).T)
        # test weighting
        w = np.zeros_like(x)
        yw = y.copy()
        w[1::2] = 1
        y[0::2] = 0
        wcoef3 = cheb.chebfit(x, yw, 3, w=w)
        assert_almost_equal(wcoef3, coef3)
        #
        wcoef2d = cheb.chebfit(x, np.array([yw,yw]).T, 3, w=w)
        assert_almost_equal(wcoef2d, np.array([coef3,coef3]).T)

        #test NA
        y = f(x)
        y[10] = 100

        xm = x.view(maskna=1)
        xm[10] = np.NA
        res = cheb.chebfit(xm, y, 3)
        assert_almost_equal(res, coef3)

        ym = y.view(maskna=1)
        ym[10] = np.NA
        res = cheb.chebfit(x, ym, 3)
        assert_almost_equal(res, coef3)

        y2 = np.vstack((y,y)).T
        y2[10,0] = 100
        y2[15,1] = 100
        y2m = y2.view(maskna=1)
        y2m[10,0] = np.NA
        y2m[15,1] = np.NA
        res = cheb.chebfit(x, y2m, 3).T
        assert_almost_equal(res[0], coef3)
        assert_almost_equal(res[1], coef3)

        wm = np.ones_like(x, maskna=1)
        wm[10] = np.NA
        res = cheb.chebfit(x, y, 3, w=wm)
        assert_almost_equal(res, coef3)
Beispiel #51
0
	def fit_continuum(self, deg):
		inds=np.where(self.mask !=0 )
		x_to_fit=self.xdata[inds]
		y_to_fit=self.ydata[inds]
		self.cont_fit=chebyshev.chebval(self.xdata, chebyshev.chebfit(x_to_fit,y_to_fit,deg))
def approximate_curve(x, y, xnew, curved_coef):
    """returns ynew - y values of some curve approximation"""
    if no_numpy:
        return None

    return chebval(xnew, chebfit(x, y, curved_coef))
Beispiel #53
0
def approximate_curve(x, y, xnew, curved_coef):
    """returns ynew - y values of some curve approximation"""
    if no_numpy:
        raise ValueError("No numpy found")

    return chebval(xnew, chebfit(x, y, curved_coef))
def GetChebyshevCoeffs(data, pvals, order=5):
    pmid = pvals[pvals.size / 2]
    prange = pvals[-1] - pvals[0]
    nvals = (pvals - pmid) / (prange / 2.0)

    return chebyshev.chebfit(nvals, data.x, order)
  raise RuntimeError("%d rows is not a multiple of 64" % nrows)
num_spectra = nrows/64
use_spectra = user_input("Select spectra",range(num_spectra)).split(',')

avg = zeros(64)
for spectrum in use_spectra:
  base_index = int(spectrum)*64
  for index in range(64):
    avg[index] += data[base_index+index,1]
averages = avg/num_spectra
# normalize the spectrum
mean = averages.mean()
averages /= mean
# fit the normalized spectrum
freqs = data[:64,0] - data[:64,0].mean()
coefs = chebfit(freqs,averages,11)
model = chebval(freqs,coefs)

freqstep = freqs[1]-freqs[0]
bandwidth = freqs[-1]-freqs[0]+freqstep
coeffile = open("baseline_coefs.pkl","rb")
try:
  coef_dict = load(coeffile)
  print "Loaded:",coef_dict.keys()
except EOFError:
  print "Empty coefficients file"
coeffile.close()
try:
  coef_dict[bandwidth] = coefs
except NameError:
  coef_dict = {bandwidth: coefs}