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)
# 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',
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('.')
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
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)
# -*- 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])
# -*- 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')
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))
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})$')
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]
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)
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]
# -*- 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
'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
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()))
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.
# -*- 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