Exemple #1
0
def HIIrecover_loop(ima, ima_err, name, plot=False, p=0, F_min=0):
    if F_min == 0:
        fmin = 0
        F_min = flux_min(ima, name)
    else:
        fmin = F_min
    IP, JP = max_coord(ima, name, 0.0)
    IP2, JP2 = [], []
    (n, m) = np.shape(ima)
    l = 17  #default box size
    cont = []
    I, J = [], []
    h = 0
    H = []
    K = []
    gauss_param = []
    counter = 0
    map_data = ima.data
    IPd = []
    JPd = []
    IPs = []
    JPs = []
    chi2_basicfit, chi2_dualfit, chi2_gfit, chi2, parameter = 0, 0, 0, 0, 0
    alpha_list = []
    sig = scale_based_on_redshift(redshift_input)
    for i in range(0, len(IP)):
        ip, jp = IP[i], JP[i]
        k = 3 * sig
        subima = ima.subimage(center=(jp, ip),
                              size=(k, k),
                              unit_center=None,
                              unit_size=None)
        subima_err = ima_err.subimage(center=(jp, ip),
                                      size=(k, k),
                                      unit_center=None,
                                      unit_size=None)
        subima_err = error_ponderation(subima_err)
        size = np.shape(subima)
        center = center2sub(x=jp, y=ip, ima=ima, subima=subima)

        subima.unmask()
        subima.mask_region(center=[(size[0] // 2) - 1, (size[1] // 2) - 1],
                           radius=k // 2,
                           unit_center=None,
                           unit_radius=None,
                           inside=False)

        try:
            xy_mesh, coeff, fit_errors = gauss2D_fit(ima, subima, subima_err,
                                                     center)
            try:
                gfitim = gaussian_2dc(xy_mesh, coeff[0], coeff[1], coeff[2],
                                      coeff[3], coeff[4])
            except:
                print('gaussian fit failed')
            parameter = 4
            chi2_basicfit = chi_square(subima, subima_err, gfitim, parameter)
            alpha = 0
            alpha_list.append(alpha)

            #            if (coeff[0] > F_min) and (fit_errors[3] < 0.08*coeff[3]) and (((size[0]/2-coeff[1])**2 + (size[1]/2-coeff[2])**2)**0.5 < 3) and (coeff[3] < redshift(name)) and (coeff[3]>0.5):
            if (coeff[0] > F_min) and (fit_errors[3] < 0.08 * coeff[3]) and (
                ((size[0] / 2 - coeff[1])**2 +
                 (size[1] / 2 - coeff[2])**2)**0.5 < 3) and (
                     coeff[3] < scale_based_on_redshift(redshift_input)) and (
                         coeff[3] > 0.5):
                gfitim = gaussian_2dc(xy_mesh, coeff[0], coeff[1], coeff[2],
                                      coeff[3], coeff[4])
                center = sub2center(coeff[1], coeff[2], ima, subima)
                if plot == True:
                    fig, ax = plt.subplots(1,
                                           4,
                                           figsize=(16, 4),
                                           tight_layout=True)
                    counter += 1
                    gfitim = gaussian_2dc(xy_mesh, coeff[0], coeff[1],
                                          coeff[2], coeff[3], coeff[4])
                    gfitim = Image(data=gfitim, wcs=subima.wcs)
                    gfitim.plot(
                        ax=ax[1],
                        colorbar='v',
                        vmax=np.amax(subima.data),
                        title=r'Simple Gauss2D FIT - flux = %s [10$^{-16}$ cgs]'
                        % round(np.sum(gfitim.data), 2))
                    subima.plot(colorbar='v',
                                ax=ax[0],
                                vmin=0,
                                zscale=False,
                                title='HII number %s' % (counter))
                    res = Image(data=(subima.data - gfitim.data),
                                wcs=subima.wcs)
                    res.plot(ax=ax[2],
                             vmin=0,
                             vmax=np.amax(subima.data),
                             colorbar='v',
                             title=r'Residuals - flux = %s [10$^{-16}$ cgs]' %
                             round(np.sum(res.data), 2))
                    res.plot(ax=ax[3],
                             vmin=-F_min,
                             vmax=F_min,
                             colorbar='v',
                             title=r'Residuals - flux = %s [10$^{-16}$ cgs]' %
                             round(np.sum(res.data), 2))
                    plt.savefig(
                        OUTPUT_IMAGES_PATH +
                        'gaussfit{}/gfit_num_{}.png'.format(p, counter),
                        bbox_inches='tight',
                        transparent=True)
                    plt.close()
                if (center[0] < n) and (center[1] < m) and (
                        center[0] > 0) and (center[1] > 0):
                    JP2.append(center[0])
                    IP2.append(center[1])
                    JPs.append(center[0])
                    IPs.append(center[1])
                    gauss_param.append([
                        center[0], center[1], coeff[3], coeff[3],
                        map_data[int(center[0])][int(center[1])], 0.0,
                        coeff[4], coeff[0], 0, chi2_basicfit, k, F_min
                    ])
                    J.append(center[0] + l)
                    I.append(center[1] + l)
                    J.append(center[0] + l)
                    I.append(center[1] - l)
                    J.append(center[0] - l)
                    I.append(center[1] - l)
                    J.append(center[0] - l)
                    I.append(center[1] + l)
                    cont.append(coeff[4])
                    cont.append(coeff[4])
                    cont.append(coeff[4])
                    cont.append(coeff[4])

        except:
            chi2_basicfit = 10

    # plt.figure()
    # plt.hist(alpha_list, color='darkmagenta')

    return IP2, JP2, gauss_param, I, J, cont, IPd, JPd, IPs, JPs
Exemple #2
0
def HIIplot(ima, param, plot=False):
    map_gfitim = np.zeros_like(ima)
    (n, m) = np.shape(ima)

    x = np.linspace(0, m, m)
    y = np.linspace(0, n, n)
    xy_mesh = np.meshgrid(x, y)

    alpha, I1, xc1, yc1, sigma1, I2, xc2, yc2, sigma2, cont, chi2, size = param

    if alpha[0] == 0:
        gfitim = gaussian_2dc(xy_mesh, I1[0], xc1[0], yc1[0], sigma1[0], 0.0)

    elif alpha[0] == 1:
        gfitim = bimodal_gaussian_2d(xy_mesh, I1[0], xc1[0], yc1[0], sigma1[0],
                                     I2[0], xc2[0], yc2[0], sigma2[0], 0.0)

    elif alpha[0] == 2:
        gfitim = gauss_image(shape=(n, m),
                             gauss=None,
                             center=(xc1[0], yc1[0]),
                             unit_center=None,
                             unit_fwhm=u.arcsec,
                             flux=I1[0],
                             peak=True,
                             rot=0.0,
                             fwhm=(sigma1[0], sigma1[0]),
                             cont=0.0,
                             wcs=ima.wcs,
                             unit=ima.unit)
        gfitim = gfitim.data

    for i in range(1, len(alpha)):
        if alpha[i] == 0:
            gfitim = gfitim + gaussian_2dc(xy_mesh, I1[i], xc1[i], yc1[i],
                                           sigma1[i], 0.0)

        elif alpha[i] == 1:
            gfitim = gfitim + bimodal_gaussian_2d(
                xy_mesh, I1[i], xc1[i], yc1[i], sigma1[i], I2[i], xc2[i],
                yc2[i], sigma2[i], 0.0)

        elif alpha[i] == 2:
            gfitim2 = gauss_image(shape=(n, m),
                                  gauss=None,
                                  center=(xc1[i], yc1[i]),
                                  unit_center=None,
                                  unit_fwhm=u.arcsec,
                                  flux=I1[i],
                                  peak=True,
                                  rot=0.0,
                                  fwhm=(sigma1[i], sigma1[i]),
                                  cont=0.0,
                                  wcs=ima.wcs,
                                  unit=ima.unit)
            gfitim = gfitim + gfitim2.data

    if plot == True:
        plt.figure()
        gfitim = Image(data=(gfitim), wcs=ima.wcs)
        gfitim.plot(scale='log',
                    vmin=0,
                    vmax=np.amax(ima.data),
                    colorbar='v',
                    zscale=False)
        plt.show()

    return gfitim
Exemple #3
0
def xav_explorer(ima, ima_err, name, plot=False):
    F_min = flux_min(ima, name)
    IP2, JP2, gauss_im, I2, J2, pcont2, IPd, JPd, IPs, JPs = HIIrecover_loop(
        ima, ima_err, name=name, plot=False, F_min=0, p=0)
    gfitim, cont2, param = HIIplot2(IPs, JPs, gauss_im, ima, param=False)
    JP3, IP3, tcont = background_interpolation(ima, name)
    grid = interpolate_continuum(ima=ima,
                                 JP=JP2,
                                 IP=IP2,
                                 I=I2,
                                 J=J2,
                                 pcont=pcont2,
                                 cont=cont2,
                                 JP3=JP3,
                                 IP3=IP3,
                                 tcont=tcont,
                                 plot=False)
    gfitim2 = HIIplot_cont(gfitim, grid, ima)
    #res = Image(data=(ima.data - gfitim.data), wcs=ima.wcs)
    p = 0
    print(p)
    gfitim, gfitim2, IP2, JP2, IPd, JPd, grid, param = loop2(IP2,
                                                             JP2,
                                                             I2,
                                                             J2,
                                                             pcont2,
                                                             cont2,
                                                             gfitim,
                                                             gfitim2,
                                                             ima,
                                                             ima_err,
                                                             IPd,
                                                             JPd,
                                                             param,
                                                             JP3,
                                                             IP3,
                                                             tcont,
                                                             name,
                                                             plot=False)
    res2 = Image(data=(ima.data - gfitim2.data), wcs=ima.wcs)

    catal = cat(param, name)
    I_list = chi_histogram(param, plot=True)
    b = 0
    for k in range(0, len(I_list)):
        catal.remove_row(I_list[k] - b)
        b += 1
    #param2 = read(cat=catal)
    #gftim = HIIplot(ima, param2)
    gfitim2 = HIIplot_cont(gfitim, grid, ima)

    #ima = Image(filename=DATA_PATH + '{}_flux_drz.fits'.format(name))
    ima2 = ima[:, :]
    #if name == 'ASASSN14jg':
    #    ima2=ima2[40:290, 20:260]
    chi2_global = chi_square(subima=ima2,
                             subima_err=ima_err,
                             gfitim=gfitim2,
                             parameter=1)
    alpha = catal['alpha']

    #Table with important data for plotting HII regions
    data = [len(alpha), chi2_global, F_min]
    CreateTable(name, OUTPUT_TABLES_PATH, data)
    print(IPd, JPd)

    if plot == True:
        #        fig, ax = plt.subplots(2, 3, constrained_layout=True)
        fig, ax = plt.subplots(2, 3, figsize=(12, 8))
        fig.suptitle('# {} HII regions - Chi2 {}'.format(
            len(alpha), np.round(chi2_global, 2)),
                     fontsize=16)
        ima.plot(scale='log',
                 colorbar='v',
                 ax=ax[0, 0],
                 vmin=0,
                 vmax=0.9 * np.amax(ima.data),
                 zscale=False,
                 title=r'flux = %s [10$^{-16}$ cgs]' %
                 (np.round(np.sum(ima.data), 2)))
        ax[0, 1].scatter(IPd, JPd, color='red', marker='.', linewidth=0.01)
        #res = Image(data=(ima.data - gfitim.data), wcs=ima.wcs)
        gfitim.plot(scale='log',
                    vmin=0,
                    vmax=0.9 * np.amax(ima.data),
                    colorbar='v',
                    ax=ax[0, 1],
                    zscale=False,
                    title=r'flux = %s [10$^{-16}$ cgs]' %
                    (np.round(np.sum(gfitim.data), 2)))
        gfitim2.plot(scale='log',
                     vmin=0,
                     vmax=0.9 * np.amax(ima.data),
                     colorbar='v',
                     ax=ax[0, 2],
                     zscale=False,
                     title=r'flux = %s [10$^{-16}$ cgs]' %
                     (np.round(np.sum(gfitim2.data), 2)))
        grid.plot(scale='log',
                  vmin=0,
                  vmax=0.9 * np.amax(ima.data),
                  colorbar='v',
                  ax=ax[1, 0],
                  zscale=False,
                  title=r'flux = %s [10$^{-16}$ cgs]' %
                  (np.round(np.sum(grid.data), 2)))
        res2 = Image(data=(ima.data - gfitim2.data), wcs=ima.wcs)
        print('RESIDUALS: mean = {}, median = {}, std = {}'.format(
            np.round(np.mean(np.ravel(res2.data)), 2),
            np.round(np.median(np.ravel(res2.data)), 2),
            np.round(np.std(np.ravel(res2.data)), 2)))  #
        #F_min
        #        res2.plot(vmin=np.amin(res2.data), vmax=np.amax(res2.data), colorbar='v', ax=ax[1,1],   zscale=False, title=r'flux = %s [10$^{-20}$ cgs]'%( np.round(np.sum(res2.data),2)))
        print("F_min" + str(F_min))
        res2.plot(vmin=-3 * F_min,
                  vmax=3 * F_min,
                  colorbar='v',
                  ax=ax[1, 1],
                  zscale=False,
                  title=r'flux = %s [10$^{-16}$ cgs]' %
                  (np.round(np.sum(res2.data), 2)))
        res2.plot(scale='log',
                  vmin=0,
                  vmax=0.9 * np.amax(ima.data),
                  colorbar='v',
                  ax=ax[1, 2],
                  zscale=False,
                  title='mean = {}, median = {}, std = {}'.format(
                      np.round(np.mean(np.ravel(res2.data)), 3),
                      np.round(np.median(np.ravel(res2.data)), 3),
                      np.round(np.std(np.ravel(res2.data)), 3)))
        fig.tight_layout()
        fig.savefig(OUTPUT_IMAGES_PATH + 'HII_recover_{}.pdf'.format(name),
                    bbox_inches='tight',
                    transparent=True)
        fig.savefig(OUTPUT_IMAGES_PATH + 'HII_recover_{}.png'.format(name),
                    bbox_inches='tight',
                    transparent=True)
        plt.close()

    #res.write('res')
    gfitim.write(name + '_gfitim_xav_fm.fits')
    gfitim2.write(name + '_gfitim2_xav_fm.fits')
    grid.write(name + '_grid_xav_fm.fits')
    res2.write(name + '_res2_xav_fm.fits')

    return catal, grid, res2, gfitim, gfitim2, chi2_global
Exemple #4
0
for i in range(len(directories)):
    #Opening FITS data for gaussian and diffuse regions
    gfitim = Image(os.getcwd() + '/' + name + '/' + directories[i]  + '/N3614p_gfitim_' + ID[i] + '.fits')
    gfitim2 = Image(os.getcwd() + '/' + name + '/' + directories[i]  + '/N3614p_gfitim2_' + ID[i] + '.fits')
    grid = Image(os.getcwd() + '/' + name + '/' + directories[i]  + '/N3614p_grid_' + ID[i] + '.fits')
    res2 = Image(os.getcwd() + '/' + name + '/' + directories[i]  + '/N3614p_res2_' + ID[i] + '.fits')

    #Obtaining values such as gaussian regions quantity and min flux from table 
    table = np.genfromtxt(os.getcwd() + '/' + name + '/' + directories[i] + '/data_N3614p_' + ID[i] + '.csv', delimiter = ',', skip_header=0)
    alpha, chi2_global, F_min = float(table[0]), float(table[1]), float(table[2])
    
    #Plotting figure
    fig, ax = plt.subplots(2, 3, figsize=(12,8))
    fig.suptitle('# {} HII regions - Chi2 {}'.format(alpha,np.round(chi2_global,2)), fontsize=16)

    ima.plot(scale='log', colorbar='v', ax=ax[0,0], vmin=0, vmax=0.9*np.amax(ima.data), zscale=False, title=r'flux = %s [10$^{-16}$ cgs]'%( np.round(np.sum(ima.data),2)))
    #ax[0,1].scatter(IPd,JPd, color='red', marker='.', linewidth=0.01)
    gfitim.plot(scale='log', vmin=0, vmax=0.9*np.amax(gfitim.data), colorbar='v', ax=ax[0,1],   zscale=False, title=r'flux = %s [10$^{-16}$ cgs]'%( np.round(np.sum(gfitim.data),2)))
    gfitim2.plot(scale='log', vmin=0, vmax=0.9*np.amax(gfitim2.data), colorbar='v', ax=ax[0,2],   zscale=False, title=r'flux = %s [10$^{-16}$ cgs]'%( np.round(np.sum(gfitim2.data),2)))
    grid.plot(scale='log', vmin=0, vmax=0.9*np.amax(grid.data), colorbar='v', ax=ax[1,0],   zscale=False, title=r'flux = %s [10$^{-16}$ cgs]'%( np.round(np.sum(grid.data),2)))

    res2.plot(vmin=-3*F_min, vmax=3*F_min, colorbar='v', ax=ax[1,1],   zscale=False, title=r'flux = %s [10$^{-16}$ cgs]'%( np.round(np.sum(res2.data),2)))

    res2.data[res2.data < 0] = 0
    res2.plot(scale='log', vmin=0, vmax=0.9*np.amax(res2.data), colorbar='v', ax=ax[1,2],   zscale=False, title='mean = {}, median = {}, std = {}'.format(np.round(np.mean(np.ravel(res2.data)),3), np.round(np.median(np.ravel(res2.data)),3), np.round(np.std(np.ravel(res2.data)),3)))
    fig.tight_layout()

    # Save plotting in pdf and png
    #fig.savefig(OUTPUT_IMAGES_PATH + 'HII_recover_{}.pdf'.format(name), bbox_inches='tight', transparent=True)
    #fig.savefig(OUTPUT_IMAGES_PATH + 'HII_recover_{}.png'.format(name), bbox_inches='tight', transparent=True)