Ejemplo n.º 1
0
from cube_analysis.rotation_curves import update_galaxy_params

from paths import fourteenB_HI_data_path, fourteenB_HI_data_wGBT_path

# The models from the peak velocity aren't as biased, based on comparing
# the VLA and VLA+GBT velocity curves. Using these as the defaults

folder_name = "diskfit_peakvels_noasymm_noradial_nowarp_output"

param_name = \
    fourteenB_HI_data_path("{}/rad.out.params.csv".format(folder_name))

param_table = Table.read(param_name)

gal = Galaxy("M33")

update_galaxy_params(gal, param_table)

# Load in the model from the feathered data as well.
folder_name = "diskfit_peakvels_noasymm_noradial_nowarp_output"

param_name = \
    fourteenB_HI_data_wGBT_path("{}/rad.out.params.csv".format(folder_name))

param_table = Table.read(param_name)

gal_feath = Galaxy("M33")

update_galaxy_params(gal_feath, param_table)
Ejemplo n.º 2
0
# import libraries
import numpy as np
from astropy.table import Table
from astropy.table import Column
from galaxies import Galaxy
import matplotlib as mpl
import plfit_mcstat as plf
import scipy.stats as ss

mpl.rcParams['font.family'] = 'serif'
mpl.rcParams['font.serif'] = 'Times New Roman'
mpl.rcParams['font.size'] = 12


# get info about m83
mygalaxy = Galaxy("M83")
print(mygalaxy)

# load fits file
tin = Table.read('m83.co10.K_props_clfind.fits')

minmass_global = 3.35e5
minmass = 3.35e5
# find cloud's galactocentric distance
rgal = mygalaxy.radius(ra=(tin['XPOS']), dec=(tin['YPOS']))
colrgal = Column(name='RGAL_PC', data=(rgal))
tin.add_column(colrgal)

t = Table(names=['Rmin', 'Rmax', 'Rmean', 'R_tpl', 'p_tpl', 'index',
                 'index_tpl', 'Mtrunc_tpl',
                 'M1', 'M5', 'Mean5', 'Mmean',
Ejemplo n.º 3
0
R = np.arange(10,1000)
S = np.power(np.pi,1/2)*R/3.4
sigmav = np.sqrt(S)
one = np.arange(10000,10000000000,10000)

#Virial Mass best fit line
M_vir = 540*np.power(R,2)

#Luminous Mass best fit line
M_lum = 2000*np.power(np.power(M_vir/39,1.234567901)/130,0.8)

#Sigma_0, Mass Density, R_gal
sigma0 = mytable['VRMS_EXTRAP_DECONV']/np.sqrt(mytable['RADRMS_EXTRAP_DECONV'])  
M_den = mytable['MASS_EXTRAP']/(np.pi*np.power(mytable['RADRMS_EXTRAP_DECONV'],2)) 

mygalaxy = Galaxy("M100")
cpropstable = Table.read('m100.co10.kkms_props_cprops.fits')
rgal=mygalaxy.radius(ra = cpropstable['XPOS'], dec = cpropstable['YPOS'])

#indexes for low R_gal group 
index = np.where(rgal.value < 1100)	
	
##PLOTS##

#Virial mass vs.luminous mass plot
figure = plt.figure(figsize=(4.5,4)) #figure size in inches
line1, line2 = plt.loglog(one,one, mytable['MASS_EXTRAP'],mytable['VIRMASS_EXTRAP_DECONV'])
line1.set_linestyle('-')
line1.set_color('k')
line2.set_linestyle('None')
line2.set_marker('.')
Ejemplo n.º 4
0
import numpy as np
from astropy.table import Table
from astropy.table import Column
# import matplotlib.pyplot as plt
import powerlaw
from galaxies import Galaxy
import matplotlib as mpl
from sklearn.cluster import k_means

mpl.rcParams['font.family'] = 'serif'
mpl.rcParams['font.serif'] = 'Times New Roman'
mpl.rcParams['font.size'] = 12

# get info about m83
mygalaxy = Galaxy("M83")
print(mygalaxy)

# load fits file
tin = Table.read('m83.co10.K_props_clfind.fits')

minmass_global = 4e5
minmass = 4e5
# find cloud's galactocentric distance
tin = tin[tin['MASS_GCORR'] > minmass_global]
rgal = mygalaxy.radius(ra=(tin['XPOS']), dec=(tin['YPOS']))
xgal, ygal = mygalaxy.radius(ra=(tin['XPOS']), dec=(tin['YPOS']),
                             returnXY=True)
_, labels, _ = k_means(np.c_[xgal.value, ygal.value], 20)

colrgal = Column(name='RGAL_PC', data=(rgal))
tin.add_column(colrgal)
sigmav = np.sqrt(S)
one = np.arange(10000, 10000000000, 10000)

#Virial Mass best fit line
M_vir = 540 * np.power(R, 2)

#Luminous Mass best fit line
M_lum = 2000 * np.power(np.power(M_vir / 39, 1.234567901) / 130, 0.8)

#Sigma_0, Mass Density, R_gal
sigma0 = mytable['VRMS_EXTRAP_DECONV'] / np.sqrt(
    mytable['RADRMS_EXTRAP_DECONV'])
M_den = mytable['MASS_EXTRAP'] / (np.pi *
                                  np.power(mytable['RADRMS_EXTRAP_DECONV'], 2))

mygalaxy = Galaxy("M100")
cpropstable = Table.read('m100.co10.kkms_props_cprops.fits')
rgal = mygalaxy.radius(ra=cpropstable['XPOS'], dec=cpropstable['YPOS'])

#indexes for low R_gal group
index = np.where(rgal.value < 1100)

##PLOTS##

#Virial mass vs.luminous mass plot
figure = plt.figure(figsize=(4.5, 4))  #figure size in inches
line1, line2 = plt.loglog(one, one, mytable['MASS_EXTRAP'],
                          mytable['VIRMASS_EXTRAP_DECONV'])
line1.set_linestyle('-')
line1.set_color('k')
line2.set_linestyle('None')
M_vir = 540*np.power(R,2)

#Luminous Mass best fit line
M_lum = 2000*np.power(np.power(M_vir/39,1.234567901)/130,0.8)

#Sigma_0, Mass Density, R_gal
sigma0 = mytable['VRMS_EXTRAP_DECONV']/np.sqrt(mytable['RADRMS_EXTRAP_DECONV'])  
M_den = mytable['MASS_EXTRAP']/(np.pi*np.power(mytable['RADRMS_EXTRAP_DECONV'],2)) 

#Surface density derived from radarea instead of radrms
high_Mden = np.where(M_den > 1000)
den_check = mytable['MASS_EXTRAP']/(np.pi*np.power(mytable['RADAREA_DECONV'],2))
test = [40,44,94,104] # Marks the arm cloud that moves to a higher density

#galactocentric radii
mygalaxy = Galaxy("M100")
cpropstable = Table.read('m100.co10.kkms_props_cprops_subsets_improved.fits')
x, y = mygalaxy.radius(ra = mytable['XPOS'], dec = mytable['YPOS'], returnXY = True)
rgal=mygalaxy.radius(ra = cpropstable['XPOS'], dec = cpropstable['YPOS'])

#indexes for low R_gal group 
index = np.where(rgal.value < 1100)	
centre_in = np.where(mytable['Nuclear'] == True)
arm_in = np.where(mytable['Arms'] == True)	
interarm_in = np.where(mytable['Interarm'] == True)
outliers = np.where(mytable['Outliers'] == True)

#Area of each region in kpc2 sr kpc^2 as found by region_areas.py 
area_arm = 99.0712520445
area_interarm = 106.465208911
area_nuc = 4.20965755925
Ejemplo n.º 7
0
from astropy.table import Table
from scipy.spatial import Voronoi
import matplotlib.path as mplPath
import astropy.wcs as wcs
from astropy.io import fits
import astropy.units as u
import numpy as np
from galaxies import Galaxy

m100 = Galaxy('M100')
tbl = Table.read('m100.co10.kkms_props_cprops_withSFR_subsets.fits')
hdr = fits.Header.fromtextfile('m100.header')
w = wcs.WCS(hdr)
ypix,xpix = np.meshgrid(np.linspace(0,799,800),np.linspace(0,799,800))
ra,dec = w.celestial.wcs_pix2world(xpix,ypix,0)
radius = m100.radius(ra=ra,dec=dec)

rclds = m100.radius(ra=tbl[~tbl['Outliers']]['XPOS'],dec=tbl[~tbl['Outliers']]['YPOS'])
maxrad = np.max(rclds.value)
xcloud,ycloud,zcloud = w.wcs_world2pix(tbl['XPOS'],tbl['YPOS'],tbl['VPOS'],0)
vor = Voronoi(zip(xcloud,ycloud))
label = np.zeros((800,800),dtype=np.str)
keys = ['Nuclear','Interarm','Arm']

for idx,region in enumerate(vor.regions):
    verts = vor.vertices[region]
    path = mplPath.Path(verts)
    inout = path.contains_points(zip(xcloud,ycloud))
    regions = path.contains_points(zip(xpix.ravel(),ypix.ravel()))
    thislabel = tbl[inout][keys]
    print(thislabel)
Ejemplo n.º 8
0
# -*- coding: utf-8 -*-

#import libraries
import astropy
import astropy.table
import numpy as np
from astropy.table import Table
from astropy.table import Column
import matplotlib.pyplot as plt
import powerlaw
from galaxies import Galaxy
import astropy.units as u
from tabulate import tabulate

#get info about m83
mygalaxy = Galaxy("M83")
print(mygalaxy)

#load fits file
t = Table.read('/home/pafreema/Documents/m83.co10.K_props_cprops.fits')

#find cloud's galactocentric distance
rgal = mygalaxy.radius(ra=(t['XPOS']), dec=(t['YPOS']))

#add those distances to the fits table
colrgal = Column(name='RADIUS_PC', data=(rgal))
t.add_column(colrgal)
#print(t)

#create a loop to input multiple bin noundaries
inneredge = np.array([0, 450, 2300, 3200, 3900])
Ejemplo n.º 9
0
# -*- coding: utf-8 -*-

#import libraries
import astropy
import astropy.table
import numpy as np
from astropy.table import Table
import matplotlib.pyplot as plt
from galaxies import Galaxy
import astropy.units as u

mygalaxy = Galaxy("M83")
print(mygalaxy)

mytable = Table.read('/home/pafreema/Documents/m83.co10.K_props_cprops.fits')

idx = np.where(np.isfinite(
    mytable['VIRMASS_EXTRAP_DECONV']))  #removes values that are infinite/NaN

rgal = mygalaxy.radius(ra=(mytable['XPOS'][idx]), dec=(mytable['YPOS'][idx]))
#print rgal #get radii in parsecs

sigma = (mytable['VRMS_EXTRAP_DECONV'][idx]) / np.sqrt(
    (mytable['RADRMS_EXTRAP_DECONV'][idx])**2)  #sigma naught
dens = (mytable['MASS_EXTRAP'][idx]) / (np.pi * (
    (mytable['RADRMS_EXTRAP_DECONV'][idx])**2))  #mass density

m, b = np.polyfit(np.log(dens), np.log(sigma), 1)
x = np.linspace(10, 10e4, 100)
figure = plt.figure(figsize=(4.5, 4))
plt.scatter(dens, sigma, c=rgal, marker='s')
Ejemplo n.º 10
0
import astropy
# import astropy.table
import numpy as np
from astropy.table import Table
from astropy.table import Column
import matplotlib.pyplot as plt
# import powerlaw
from galaxies import Galaxy
# import astropy.units as u
import matplotlib as mpl
import astropy.io.fits as fits
mpl.rcParams['font.family'] = 'serif'
mpl.rcParams['font.serif'] = 'Times New Roman'
mpl.rcParams['font.size'] = 14
#get info about m83
mygalaxy = Galaxy("M83")
print(mygalaxy)

# load fits file
t = Table.read('m83.co10.K_props_clfind.fits')
# import astropy.wcs as wcs

data = fits.getdata('m83.co10.tmax.fits')
hdr = fits.getheader('m83.co10.tmax.fits')
rgal_img = (mygalaxy.radius(header=hdr)).value

# find cloud's galactocentric distance


rgal = mygalaxy.radius(ra=(t['XPOS']), dec=(t['YPOS']))
colrgal = Column(name='RGAL_PC', data=(rgal))
Ejemplo n.º 11
0
from astropy.io import fits
from astropy.table import Table
from galaxies import Galaxy
import matplotlib.pyplot as mpl
import aplpy
import numpy as np
from radial_profile import lundgren_surfdens
import astropy.units as u

mpl.rcParams['font.family'] = 'serif'
mpl.rcParams['font.serif'] = 'Times New Roman'

mygalaxy = Galaxy("M83")

hdu = fits.open('m83.co10.tmax.fits')
rgal = mygalaxy.radius(header=hdu[0].header) / 1e3
hdr = hdu[0].header
del hdr['CDELT3']
del hdr['CRPIX3']
del hdr['CRVAL3']
# del hdr['NAXIS3']
del hdr['CTYPE3']
del hdr['CUNIT3']
hdr['WCSAXES'] = 2
newhdu = fits.PrimaryHDU(hdu[0].data, hdr)
radii = fits.PrimaryHDU(rgal, hdr)
map = aplpy.FITSFigure(newhdu)
map.show_colorscale(cmap='Greys', vmin=2.4, vmax=8, stretch='sqrt')
map.add_colorbar()
map.tick_labels.set_font(family='serif')
map.colorbar.set_axis_label_text(r'$T_{\mathrm{max}}\ (\mathrm{K})$')
Ejemplo n.º 12
0
def data(galaxyname, data, n_bins=1, r_nuc=0):

    # Import the libraries.
    from galaxies import Galaxy
    from astropy.table import Table
    from astropy.table import Column
    import astropy
    import powerlaw
    import numpy as np
    import astropy.table
    import astropy.units as u
    import matplotlib.pyplot as plt
    import matplotlib as mpl

    # Load its FITS file.
    t = Table.read(data)

    # Load the information about the galaxy.
    gxy = Galaxy(galaxyname)

    # Calculate the galaxy's properties.
    distance = np.asarray(gxy.distance)
    inclination = np.asarray(gxy.inclination)
    rgal = gxy.radius(ra=(t['XPOS']), dec=(t['YPOS']))
    rgal = rgal.to(u.kpc)
    rpgal = np.asarray(rgal)

    # Append these to the FITS table.
    col_rgal = Column(name='RADIUS_KPC', data=(rgal))
    t.add_column(col_rgal)

    # Sort the masses according to galactocentric radius.
    mass = t['MASS_EXTRAP'].data
    i_sorted = np.argsort(rgal)
    rgal_sorted = np.asarray(rgal[i_sorted])
    mass_sorted = np.asarray(mass[i_sorted])

    # Initiate a loop to calculate the bin boundaries and the indeces of these boundaries in the sorted list.
    totmass = np.sum(mass) / n_bins
    edge_f = 1.1 * np.max(rgal_sorted)
    edges = np.zeros(n_bins - 1)
    start = 0
    mass_equiv = [0]  #indeces for the sorted mass bins of equal mass
    mass_area = [0]  #indeces for the sorted mass bins of equal area
    rgal_equiv = [
        0, 2, 8**0.5, 12**0.5, 4, 20**0.5, 24**0.5, 28**0.5, 32**0.5, 6
    ]
    r = 1  #equal-area radial index
    e = 0  #edge index
    f = 0  #loop flag to skip the mass_area loop
    c = 0  #loop counter
    for i in range(len(mass_sorted)):
        #Find the indeces for bins of equal mass (equivalent to totmass)
        if np.sum(mass_sorted[start:i]) > totmass:
            edges[e] = 0.5 * (rgal_sorted[i] + rgal_sorted[i - 1])
            start = i
            mass_equiv = np.append(mass_equiv, i)
            e = e + 1
        #Find the indeces for bins of equal area (4pi kpc^2)
        if rgal_sorted[i] > rgal_equiv[r] and not f:
            if rgal_sorted[i] < rgal_equiv[3] and not f:
                mass_area = np.append(mass_area, i)
                r = r + 1
                c = 0
            if rgal_sorted[i] > rgal_equiv[3]:
                f = 1
                mass_area = np.append(mass_area, i)
    mass_equiv = np.append(mass_equiv, i)
    inneredge = np.concatenate(([0.000000], edges))
    outeredge = np.concatenate((edges, [edge_f]))

    # Create a template for a new table.
    column_names = [
        'Inner edge (kpc)', 'Outer edge (kpc)', 'GMC index', 'R', 'p',
        'Truncation mass ($M_\mathrm{\odot}$)',
        'Largest cloud ($M_\mathrm{\odot}$)',
        '5th largest cloud ($M_\mathrm{\odot}$)'
    ]
    column_types = ['f4', 'f4', 'f4', 'f4', 'f4', 'f4', 'f4', 'f4']
    table = Table(names=column_names, dtype=column_types)

    # Fill the table.
    for inneredge, outeredge in zip(inneredge, outeredge):

        idx = np.where((t['RADIUS_KPC'] >= inneredge)
                       & (t['RADIUS_KPC'] < outeredge))
        mass = t['MASS_EXTRAP'][idx].data
        fit = powerlaw.Fit(mass)
        fit_subset = powerlaw.Fit(mass, xmin=3e5)
        R, p = fit.distribution_compare('power_law', 'truncated_power_law')
        table.add_row()
        table[-1]['R'] = R
        table[-1]['p'] = p
        table[-1]['GMC index'] = -fit.alpha
        table[-1]['Inner edge (kpc)'] = inneredge
        table[-1]['Outer edge (kpc)'] = outeredge
        table[-1]['Largest cloud ($M_\mathrm{\odot}$)'] = np.nanmax(mass)
        table[-1][
            'Truncation mass ($M_\mathrm{\odot}$)'] = 1 / fit.truncated_power_law.parameter2
        table[-1]['5th largest cloud ($M_\mathrm{\odot}$)'] = np.sort(
            t['MASS_EXTRAP'][idx])[-5]

    # Write the data to a FITS file.
    table.write('../Data/' + galaxyname + '_data.fits', overwrite=True)

    # Plot the mass distribution trends for equal-mass bins.
    t = Table.read('../Data/' + galaxyname + '_data.fits')
    inneredge = t['Inner edge (kpc)'].data
    outeredge = t['Outer edge (kpc)'].data
    subplot_label = ('(a)', '(b)', '(c)', '(d)', '(e)', '(f)')
    for i in range(len(mass_equiv) - 1):

        binmass = mass_sorted[mass_equiv[i]:mass_equiv[i + 1]]
        myfit = powerlaw.Fit(binmass)
        R, p = myfit.distribution_compare('power_law', 'truncated_power_law')
        fig = myfit.truncated_power_law.plot_ccdf(label='Truncated\nPower Law')
        myfit.power_law.plot_ccdf(label='Power Law', ax=fig)
        myfit.plot_ccdf(drawstyle='steps', label='Data', ax=fig)

        # Format the plot.
        plt.legend(loc=0)
        #plt.title(galaxyname+'Equal-mass Mass Distribution, bin '+repr(i+1))
        plt.ylim(ymin=10**-3)
        plt.xlabel(r'$M_\mathrm{\odot}$', fontsize=20)
        plt.ylabel('CCDF', fontsize=20)
        mpl.rc('xtick', labelsize=16)
        mpl.rc('ytick', labelsize=16)
        plt.text(0.01,
                 0.5,
                 subplot_label[i],
                 ha='left',
                 va='center',
                 transform=fig.transAxes,
                 fontsize=16)
        plt.text(
            0.35,
            0.01,
            r'$M_{bin}\ =\ %e M_\mathrm{\odot}$' % (totmass) + '\n' +
            r'$R_{gal}\ =\ %5.4f\ \mathrm{kpc}\ \mathrm{to}\ %5.4f\ \mathrm{kpc}$'
            % (inneredge[i], outeredge[i]) + '\n' +
            r'$\mathrm{R}\ =\ %5.4f,\ \mathrm{p}\ =\ %5.4f$' % (R, p) + '\n' +
            r'$\alpha\ =\ %5.4f,\ M_\mathrm{0}\ =\ %5.4eM_\mathrm{\odot}$' %
            (-myfit.alpha, 1 / myfit.truncated_power_law.parameter2),
            ha='left',
            va='bottom',
            transform=fig.transAxes,
            fontsize=16)
        plt.savefig('../Data/' + galaxyname + '_power_law_equal_mass_' +
                    repr(i + 1) + '.png')
        plt.close()

    # Plot the mass distribution trend for equal-area bins.
    for i in range(len(mass_area) - 1):

        f = 0  #loop flag
        if mass_area[i + 1] - mass_area[i] < 3:
            f = 1
        if not f:
            binmass = mass_sorted[mass_area[i]:mass_area[i + 1]]
            myfit = powerlaw.Fit(binmass)
            R, p = myfit.distribution_compare('power_law',
                                              'truncated_power_law')
            fig = myfit.truncated_power_law.plot_ccdf(
                label='Truncated\nPower Law')
            myfit.power_law.plot_ccdf(label='Power Law', ax=fig)
            myfit.plot_ccdf(drawstyle='steps', label='Data', ax=fig)

            # Format the plot.
            plt.legend(loc=0)
            #plt.title(galaxyname+'Equal-area Mass Distribution, bin '+repr(i+1))
            plt.ylim(ymin=10**-3)
            plt.xlabel(r'$M_\mathrm{\odot}$', fontsize=20)
            plt.ylabel('CCDF', fontsize=20)
            mpl.rc('xtick', labelsize=16)
            mpl.rc('ytick', labelsize=16)
            plt.text(0.01,
                     0.5,
                     subplot_label[i],
                     ha='left',
                     va='center',
                     transform=fig.transAxes,
                     fontsize=16)
            plt.text(
                0.35,
                0.01,
                r'$R_{gal}\ =\ %5.4f\ \mathrm{kpc}\ \mathrm{to}\ %5.4f\ \mathrm{kpc}$'
                % (rgal_equiv[i], rgal_equiv[i + 1]) + '\n' +
                r'$\mathrm{R}\ =\ %5.4f,\ \mathrm{p}\ =\ %5.4f$' % (R, p) +
                '\n' +
                r'$\alpha\ =\ %5.4f,\ M_\mathrm{0}\ =\ %5.4eM_\mathrm{\odot}$'
                % (-myfit.alpha, 1 / myfit.truncated_power_law.parameter2),
                ha='left',
                va='bottom',
                transform=fig.transAxes,
                fontsize=16)
            plt.savefig('../Data/' + galaxyname + '_power_law_equal_area_' +
                        repr(i + 1) + '.png')
            plt.close()

    return [distance, inclination]
Ejemplo n.º 13
0
def param(galaxyname, data, r_nuc=0):
    # This is a module that will plot graphs of the clouds' virial parameter, surface density,
    # and linewidth on a one-parsec scale to its galactocentric radius.

    # import the libraries that are needed.
    from scipy import stats as sps
    from galaxies import Galaxy
    from astropy.table import Table
    import numpy as np
    import astropy.units as u
    import matplotlib.pyplot as plt
    import matplotlib as mpl

    # Load all of the data.
    gxy = Galaxy(galaxyname)
    cpropstable = Table.read(data)

    # Extract different data set
    lw = cpropstable['VRMS_EXTRAP']
    xval = cpropstable['XPOS']
    yval = cpropstable['YPOS']
    vmass = cpropstable['VIRMASS_EXTRAP_DECONV']
    mass = cpropstable['MASS_EXTRAP']
    radrms = cpropstable['RADRMS_EXTRAP_DECONV']
    rgal = gxy.radius(ra=xval, dec=yval)
    rgal = rgal.to(u.kpc)

    # Sort the masses according to galactocentric radius.
    i_sorted = np.argsort(rgal)
    rgal_sorted = np.asarray(rgal[i_sorted])
    mass_sorted = np.asarray(mass[i_sorted])

    # Calculate the virial parameter, surface density, and linewidth on a one-parsec scale.
    alpha = vmass / mass
    sigma = mass / (radrms**2)
    lwo = lw / ((radrms)**0.5)

    # Initialize the arrays to extract the glactic disk cloud properties.
    rad_sorted = radrms[i_sorted]
    alpha_sorted = np.log10(alpha[i_sorted])
    sigma_sorted = np.log10(sigma[i_sorted])
    lwo_sorted = np.log10(lwo[i_sorted])
    #lwo_sorted = lwo[i_sorted]
    lw_sorted = lw[i_sorted]
    mass_disk = []  #mass of each disk GMC
    rad_disk = []  #radius of each disk GMC
    alpha_disk = []  #virial parameter of each disk GMC
    sigma_disk = []  #suface density of each disk GMC
    lwo_disk = []  #normalized linewidth of each disk GMC
    lw_disk = []  #linewidth of each disk GMC

    # Create a loop to extract the galactic disk GMC properties.
    for i in range(len(mass_sorted)):
        if rgal_sorted[i] > r_nuc:
            if not np.isnan(alpha_sorted[i]) and not np.isnan(
                    sigma_sorted[i]) and not np.isnan(
                        lwo_sorted[i]) and not np.isnan(lw_sorted[i]):
                mass_disk = np.append(mass_disk, mass_sorted[i])
                rad_disk = np.append(rad_disk, rad_sorted[i])
                alpha_disk = np.append(alpha_disk, alpha_sorted[i])
                sigma_disk = np.append(sigma_disk, sigma_sorted[i])
                lwo_disk = np.append(lwo_disk, lwo_sorted[i])
                lw_disk = np.append(lw_disk, lw_sorted[i])

    # Separate the data into bins, then calculate the mean values.
    binaxis = [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5]
    bin_means, bin_edges, binnumber = sps.binned_statistic(
        rgal,
        mass,
        statistic='mean',
        bins=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
    bin_medians, bin_edges, binnumber = sps.binned_statistic(
        rgal,
        mass,
        statistic='median',
        bins=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
    lwo_medians, bin_edges, binnumber = sps.binned_statistic(
        rgal,
        lwo,
        statistic=np.nanmedian,
        bins=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
    alpha_medians, bin_edges, binnumber = sps.binned_statistic(
        rgal,
        alpha,
        statistic=np.nanmedian,
        bins=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
    sigma_medians, bin_edges, binnumber = sps.binned_statistic(
        rgal,
        sigma,
        statistic=np.nanmedian,
        bins=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

    # Plot the parameters with respect to the galactocentric radius.
    figure1 = plt.figure(figsize=(15, 5))

    ax = plt.subplot(1, 3, 1)
    l1 = plt.plot(rgal, alpha)
    plt.yscale('log')
    plt.setp(l1,
             marker='D',
             markersize=5,
             linestyle='None',
             color='b',
             label='GMC',
             alpha=0.7)
    plt.errorbar(binaxis,
                 alpha_medians,
                 xerr=0.5,
                 linestyle='None',
                 marker='o',
                 color='k',
                 lw=5,
                 alpha=0.7,
                 label='Median')
    plt.legend(loc=0)
    mpl.rc('xtick', labelsize=16)
    mpl.rc('ytick', labelsize=16)
    plt.text(0.5,
             0.99,
             '(a)',
             ha='center',
             va='top',
             transform=ax.transAxes,
             fontsize=16)
    plt.xlabel(r'$R_g\ (\mathrm{kpc})$', fontsize=20)
    plt.ylabel(r'$\alpha$', fontsize=20)
    #plt.title('(a)',fontsize=20)

    ax = plt.subplot(1, 3, 2)
    l1 = plt.plot(rgal, sigma)
    plt.yscale('log')
    plt.setp(l1,
             marker='D',
             markersize=5,
             linestyle='None',
             color='b',
             label='GMC',
             alpha=0.7)
    plt.errorbar(binaxis,
                 sigma_medians,
                 xerr=0.5,
                 linestyle='None',
                 marker='o',
                 color='k',
                 lw=5,
                 alpha=0.7,
                 label='Median')
    plt.legend(loc=0)
    mpl.rc('xtick', labelsize=16)
    mpl.rc('ytick', labelsize=16)
    plt.text(0.5,
             0.99,
             '(b)',
             ha='center',
             va='top',
             transform=ax.transAxes,
             fontsize=16)
    plt.xlabel(r'$R_g\ (\mathrm{kpc})$', fontsize=20)
    plt.ylabel(r'$\Sigma\ (\frac{M_\mathrm{\odot}}{\mathrm{pc}^{2}})$',
               fontsize=20)
    #plt.title('(b)',fontsize=20)

    ax = plt.subplot(1, 3, 3)
    l1 = plt.plot(rgal, lwo)
    plt.setp(l1,
             marker='D',
             markersize=5,
             linestyle='None',
             color='b',
             label='GMC',
             alpha=0.7)
    plt.errorbar(binaxis,
                 lwo_medians,
                 xerr=0.5,
                 linestyle='None',
                 marker='o',
                 color='k',
                 lw=5,
                 alpha=0.7,
                 label='Median')
    plt.legend(loc=0)
    mpl.rc('xtick', labelsize=16)
    mpl.rc('ytick', labelsize=16)
    plt.text(0.5,
             0.99,
             '(c)',
             ha='center',
             va='top',
             transform=ax.transAxes,
             fontsize=16)
    plt.xlabel(r'$R_g\ (\mathrm{kpc})$', fontsize=20)
    plt.ylabel(r'$\sigma_{0}\ (\frac{\mathrm{km}}{\mathrm{s}})$', fontsize=20)
    #plt.title('(c)',fontsize=20)

    plt.tight_layout()
    plt.savefig('../Parameters/' + galaxyname + '_param.png')
    plt.close()

    # Make a figure of the median mass for a given radius.
    figure2 = plt.figure(figsize=(8, 8))

    plt.errorbar(binaxis,
                 bin_means,
                 xerr=0.5,
                 linestyle='None',
                 marker='D',
                 color='b',
                 label='Mean',
                 alpha=0.7)
    plt.errorbar(binaxis,
                 bin_medians,
                 xerr=0.5,
                 linestyle='None',
                 marker='D',
                 color='g',
                 label='Median',
                 alpha=0.7)
    plt.yscale('log')
    plt.legend(loc=0)
    mpl.rc('xtick', labelsize=16)
    mpl.rc('ytick', labelsize=16)
    plt.xlabel(r'$R\ (\mathrm{kpc})$', fontsize=20)
    plt.ylabel(r'$M_{\mathrm{lum}}\ (M_{\odot})$', fontsize=20)
    #plt.title('GMC Mass Distribution in '+galaxyname,fontsize=20)

    plt.tight_layout()
    plt.savefig('../Parameters/' + galaxyname + '_dist.png')
    plt.close()

    return [mass_disk, rad_disk, alpha_disk, sigma_disk, lwo_disk, lw_disk]
 def __init__(self,area=4.0*math.pi,lowz=0.0,highz=1.0):
     Galaxy.__init__(self)
     self.initSurvey(area,lowz,highz)
Ejemplo n.º 15
0
import astropy
import astropy.table
import numpy as np
from astropy.table import Table, Column
import matplotlib.pyplot as plt
from galaxies import Galaxy
import astropy.units as u
import matplotlib as mpl
import astropy.constants as con
mpl.rcParams['font.family']='serif'
mpl.rcParams['font.serif'] = 'Times New Roman'
mygalaxy=Galaxy("M83")

mytable=Table.read('m83.co10.K_props_clfind.fits')
#note that matplotlib understands LaTeX math in the code m

rgal=mygalaxy.radius(ra=(mytable['XPOS']), dec=(mytable['YPOS']))
colrgal=Column(name='RGAL_PC',data=(rgal))
mytable.add_column(colrgal)

condition = np.ones(len(mytable),dtype=np.bool)
condition = (mytable['MASS_GCORR']>4.6e5) # & (mytable['RADRMS_EXTRAP_DECONV']>20)
idx = np.where(condition)
mytable = mytable[idx]

edge_in = np.array([0,450,2300,3200,3900,4500])
edge_out = np.array([450,2300,3200,3900,4500,10000])

for ins,outs in zip(edge_in,edge_out):
    subset = (mytable['MASS_EXTRAP']>3e5)*(mytable['RGAL_PC']<=outs)*(mytable['RGAL_PC']>ins)
    tt = mytable[subset]
Ejemplo n.º 16
0
# -*- coding: utf-8 -*-

# a plot of virial mass vs luminous mass
# a plot of radius vs line width
# a plot of luminous mass vs radius

import astropy
import astropy.table
import numpy as np
from astropy.table import Table, Column
import matplotlib.pyplot as plt
from galaxies import Galaxy
import astropy.units as u

mygalaxy = Galaxy("M83")

# load the file
mytable = Table.read("/home/pafreema/Documents/m83.co10.K_props_cprops.fits")
# note that matplotlib understands LaTeX math in the code m

rgal = mygalaxy.radius(ra=(mytable["XPOS"]), dec=(mytable["YPOS"]))
colrgal = Column(name="RADIUS_PC", data=(rgal))
mytable.add_column(colrgal)

idx = np.where(np.isfinite(mytable["VIRMASS_EXTRAP_DECONV"]))  # removes values that are infinite/NaN

m, b = np.polyfit(np.log(mytable["MASS_EXTRAP"][idx]), np.log(mytable["VIRMASS_EXTRAP_DECONV"][idx]), 1)
figure = plt.figure(figsize=(4.5, 4))  # figure size in inches
plt.scatter(mytable["MASS_EXTRAP"], mytable["VIRMASS_EXTRAP_DECONV"], c=mytable["RADIUS_PC"], marker="s")
test_mass = np.logspace(5, 9, 100)
plt.plot(test_mass, np.exp(m * np.log(test_mass) + b))  # fit line for m83
Ejemplo n.º 17
0
    'logB': [],
    'logC': [],
    'logA_std': [],
    'ind_std': [],
    'logB_std': [],
    'logC_std': []
}

# for gal in ['M33', 'M31']:
for gal in ['M31']:

    plot_folder = osjoin(data_path, "{}_plots".format(gal))
    if not os.path.exists(plot_folder):
        os.mkdir(plot_folder)

    gal_obj = Galaxy(gal)
    gal_obj.distance = fitinfo_dict[gal]['distance']

    if gal == 'M31':
        # Add 180 deg to the PA
        gal_obj.position_angle += 180 * u.deg

    filename = osjoin(data_path, gal, fitinfo_dict[gal]['filename'])

    hdu_coldens = fits.open(filename)

    proj_coldens = Projection.from_hdu(
        fits.PrimaryHDU(hdu_coldens[0].data[0].squeeze(),
                        hdu_coldens[0].header))

    # Get minimal size
Ejemplo n.º 18
0
from astropy.table import Table
from scipy.spatial import Voronoi
import matplotlib.path as mplPath
import astropy.wcs as wcs
from astropy.io import fits
import astropy.units as u
import numpy as np
from galaxies import Galaxy

m100 = Galaxy('M100')
tbl = Table.read('m100.co10.kkms_props_cprops_withSFR_subsets.fits')
hdr = fits.Header.fromtextfile('m100.header')
w = wcs.WCS(hdr)
ypix, xpix = np.meshgrid(np.linspace(0, 799, 800), np.linspace(0, 799, 800))
ra, dec = w.celestial.wcs_pix2world(xpix, ypix, 0)
radius = m100.radius(ra=ra, dec=dec)

rclds = m100.radius(ra=tbl[~tbl['Outliers']]['XPOS'],
                    dec=tbl[~tbl['Outliers']]['YPOS'])
maxrad = np.max(rclds.value)
xcloud, ycloud, zcloud = w.wcs_world2pix(tbl['XPOS'], tbl['YPOS'], tbl['VPOS'],
                                         0)
vor = Voronoi(zip(xcloud, ycloud))
label = np.zeros((800, 800), dtype=np.str)
keys = ['Nuclear', 'Interarm', 'Arm']

for idx, region in enumerate(vor.regions):
    verts = vor.vertices[region]
    path = mplPath.Path(verts)
    inout = path.contains_points(zip(xcloud, ycloud))
    regions = path.contains_points(zip(xpix.ravel(), ypix.ravel()))
Ejemplo n.º 19
0
import astropy.io.fits as fits
import astropy.units as u
from spectral_cube import SpectralCube
from galaxies import Galaxy

from pandas import DataFrame, read_csv
import pandas as pd
import statsmodels.formula.api as smf

# Calculate line width, sigma; and surface density, Sigma.
alpha = 6.7
sigma = I_mom0 / (np.sqrt(2*np.pi * I_max))
Sigma = alpha*I_mom0
# Importing radius of each data point.
gal = Galaxy('NGC1672')
hdr = fits.getheader('ngc1672_co21_12m+7m+tp_mom0.fits')
rad = gal.radius(header=hdr)
rad = (rad * u.Mpc.to(u.kpc)) * u.kpc / u.Mpc           # Converts rad from Mpc to kpc.
# Calculating width of each pixel, in parsecs.
pixsizes_deg = wcs.utils.proj_plane_pixel_scales(wcs.WCS(hdr))     # The size of each pixel, in degrees. Ignore that third dimension; that's pixel size for the speed.
pixsizes = pixsizes_deg[0] * np.pi / 180.                          # Pixel size, in radians.
pcperpixel =  pixsizes*d      					   # Number of parsecs per pixel.
pcperdeg = pcperpixel / pixsizes_deg[0]                            # Number of parsecs per degree.

# Getting beam width, in degrees and parsecs.
beam = hdr['BMAJ']                                      # Beam size, in degrees
beam = beam * pcperdeg                                  # Beam size, in pc

# Import data from .fits files.
I_mom0 = fits.getdata('ngc1672_co21_12m+7m+tp_mom0.fits')      # Mass density at each pixel.
Ejemplo n.º 20
0
# -*- coding: utf-8 -*-

# import libraries
import astropy
import astropy.table
import numpy as np
from astropy.table import Table
from astropy.table import Column
import matplotlib.pyplot as plt
import powerlaw
from galaxies import Galaxy
import astropy.units as u

mygalaxy = Galaxy("M83")
print(mygalaxy)

t = Table.read("/home/pafreema/Documents/m83.co10.K_props_cprops.fits")

rgal = mygalaxy.radius(ra=(t["XPOS"]), dec=(t["YPOS"]))

colrgal = Column(name="RADIUS_PC", data=(rgal))
t.add_column(colrgal)
# print(t)

# fit for the whole galaxy
mass = t["MASS_EXTRAP"].data  # pulls out the mass variable
myfit = powerlaw.Fit(mass)

idxnuc = np.where(t["RADIUS_PC"] < 1000)
idxmass = np.where((t["MASS_EXTRAP"] > 3e5) & (t["RADIUS_PC"] < 1000))
massnuc = t["MASS_EXTRAP"][idxnuc].data