def test_create_from_dataset():
ds = fake_random_ds(16)
plot1 = yt.ProfilePlot(
ds,
("index", "radius"),
[("gas", "velocity_x"), ("gas", "density")],
weight_field=None,
)
plot2 = yt.ProfilePlot(
ds.all_data(),
("index", "radius"),
[("gas", "velocity_x"), ("gas", "density")],
weight_field=None,
)
assert_allclose_units(plot1.profiles[0][("gas", "density")],
plot2.profiles[0][("gas", "density")])
assert_allclose_units(plot1.profiles[0]["velocity_x"],
plot2.profiles[0]["velocity_x"])
plot1 = yt.PhasePlot(ds, ("gas", "density"), ("gas", "velocity_x"),
("gas", "cell_mass"))
plot2 = yt.PhasePlot(ds.all_data(), ("gas", "density"),
("gas", "velocity_x"), ("gas", "cell_mass"))
assert_allclose_units(plot1.profile["cell_mass"],
plot2.profile["cell_mass"])
def test_create_from_dataset():
ds = fake_random_ds(16)
plot1 = yt.ProfilePlot(ds, "radius", ["velocity_x", "density"],
weight_field=None)
plot2 = yt.ProfilePlot(ds.all_data(), "radius", ["velocity_x", "density"],
weight_field=None)
assert_allclose_units(
plot1.profiles[0]['density'], plot2.profiles[0]['density'])
assert_allclose_units(
plot1.profiles[0]['velocity_x'], plot2.profiles[0]['velocity_x'])
plot1 = yt.PhasePlot(ds, 'density', 'velocity_x', 'cell_mass')
plot2 = yt.PhasePlot(ds.all_data(), 'density', 'velocity_x', 'cell_mass')
assert_allclose_units(
plot1.profile['cell_mass'], plot2.profile['cell_mass'])
def generate_plot(self):
s = self.parent.active_data_object.data
xf = self.x_field.get_field
yf = self.y_field.get_fields()
wf = self.weight_field.get_field()
if wf == 'Default':
wf = 'cell_mass'
if wf == 'None':
wf = None
nb = self.n_bins.value()
accum = self.accum.currentText() == 'True'
frac = self.frac.currentText() == 'True'
xl = self.x_log.currentText() == 'True'
yl = self.y_log.currentText() == 'True'
plt = yt.ProfilePlot(s,
xf,
yf,
weight_field=wf,
n_bins=nb,
accumulation=accum,
fractional=frac,
x_log=xl,
y_log=yl)
view = PlotWindowView(plt)
self.plot_ref.addSubWindow(view)
view.show()
def test_phaseplot_set_log():
fields = ('density', 'temperature')
units = (
'g/cm**3',
'K',
)
ds = fake_random_ds(16, fields=fields, units=units)
sp = ds.sphere("max", (1.0, "Mpc"))
p1 = yt.ProfilePlot(sp, "radius", ("gas", "density"))
p2 = yt.PhasePlot(sp, ("gas", "density"), ("gas", "temperature"),
"cell_mass")
# make sure we can set the log-scaling using the tuple without erroring out
p1.set_log(("gas", "density"), False)
p2.set_log(("gas", "temperature"), False)
assert not p1.y_log["gas", "density"]
assert not p2.y_log
# make sure we can set the log-scaling using a string without erroring out
p1.set_log("density", True)
p2.set_log("temperature", True)
assert p1.y_log["gas", "density"]
assert p2.y_log
# make sure we can set the log-scaling using a field object
p1.set_log(ds.fields.gas.density, False)
p2.set_log(ds.fields.gas.temperature, False)
assert not p1.y_log["gas", "density"]
assert not p2.y_log
def test_set_labels():
ds = fake_random_ds(16)
ad = ds.all_data()
plot = yt.ProfilePlot(ad, "radius", ["velocity_x", "density"], weight_field=None)
# make sure we can set the labels without erroring out
plot.set_ylabel("all", "test ylabel")
plot.set_xlabel("test xlabel")
def test_set_units():
ds = yt.load(ETC46)
sp = ds.sphere("max", (1.0, "Mpc"))
p1 = yt.ProfilePlot(sp, "radius", ("enzo", "Density"))
p2 = yt.PhasePlot(sp, ("enzo", "Density"), ("enzo", "Temperature"),
"cell_mass")
# make sure we can set the units using the tuple without erroring out
p1.set_unit(("enzo", "Density"), "Msun/kpc**3")
p2.set_unit(("enzo", "Temperature"), "R")
def setUpClass(cls):
cls.tmpdir = tempfile.mkdtemp()
cls.curdir = os.getcwd()
os.chdir(cls.tmpdir)
ds = fake_random_ds(16)
ad = ds.all_data()
cls.fields = ["velocity_x", "velocity_y", "velocity_z"]
cls.plot = yt.ProfilePlot(ad, "radius", cls.fields, weight_field=None)
def test_set_units():
fields = ('density', 'temperature')
units = ('g/cm**3', 'K',)
ds = fake_random_ds(16, fields=fields, units=units)
sp = ds.sphere("max", (1.0, "Mpc"))
p1 = yt.ProfilePlot(sp, "radius", ("gas", "density"))
p2 = yt.PhasePlot(sp, ("gas", "density"), ("gas", "temperature"), "cell_mass")
# make sure we can set the units using the tuple without erroring out
p1.set_unit(("gas", "density"), "Msun/kpc**3")
p2.set_unit(("gas", "temperature"), "R")
def make_mass_profile(ad, yfield=('Gas', 'Mass')):
xfield = ('gas', 'spherical_position_radius')
p = yt.ProfilePlot(ad,
xfield,
yfield,
weight_field=None,
x_log=False,
n_bins=16)
p.set_unit(xfield, 'kpc')
p.set_unit(yfield, 'Msun')
profile = p.profiles[0]
rbins = profile.x
return rbins, profile[yfield]
def DM_dens_prof(ds,sph,simtype,curr_sim,curr_halo):
print datetime.now().strftime('%H:%M:%S'),'Making DM Density Profile Plot of halo #%d'%(curr_halo)
field_type = 'deposit'
field = 'io_density'
weight= None
rp = yt.create_profile(sph, 'radius', (field_type,field),weight_field=weight)
output = yt.ProfilePlot(sph, "radius", (field_type,field),x_log=None,y_log=None)
output.set_unit('radius', 'Mpccm/h')
output.set_unit(field, 'Msun/kpc**3')
output.set_log('radius',False)
output.save('%s_%s_%d_prof_%s.png'%(simtype,curr_sim,curr_halo,field))
return rp
def prof_temp_halo(ds,sph,simtype,curr_sim,curr_halo):
"This function makes a profile of the halo chosen, saves it, and returns the profile as an object for future use"
print datetime.now().strftime('%H:%M:%S'),'Making gas temperature Profile Plot of halo #%d'%(curr_halo)
fieldtype = 'gas'
field = 'temperature'
weight= None
rp = yt.create_profile(sph,'radius',(fieldtype,field),weight_field=weight)
plot = yt.ProfilePlot(sph,'radius',(fieldtype,field),weight_field=weight)
plot.set_unit('radius', 'Mpccm/h')
plot.set_unit(field, 'K')
plot.set_log('radius',False)
plot.save('%s_%s_%d_prof_%s.png'%(simtype,curr_sim,curr_halo,field))
#Return the profile object for future use.
return rp
def test_phaseplot_set_log():
ds = yt.load(ETC46)
sp = ds.sphere("max", (1.0, "Mpc"))
p1 = yt.ProfilePlot(sp, "radius", ("enzo", "Density"))
p2 = yt.PhasePlot(sp, ("enzo", "Density"), ("enzo", "Temperature"),
"cell_mass")
# make sure we can set the log-scaling using the tuple without erroring out
p1.set_log(("enzo", "Density"), False)
p2.set_log(("enzo", "Temperature"), False)
assert p1.y_log["enzo", "Density"] is False
assert p2.y_log is False
# make sure we can set the log-scaling using a string without erroring out
p1.set_log("Density", True)
p2.set_log("Temperature", True)
assert p1.y_log["enzo", "Density"] is True
assert p2.y_log is True
# make sure we can set the log-scaling using a field object
p1.set_log(ds.fields.enzo.Density, False)
p2.set_log(ds.fields.enzo.Temperature, False)
assert p1.y_log["enzo", "Density"] is False
assert p2.y_log is False
trident.add_ion_fields(ds, ['C', "O", "O IV", "O VI", "C IV"], ftype='gas')
for field in ds.derived_field_list:
print (field)
pos = ad['particle_position'][ad['particle_mass'] \
== ad['particle_mass'].max()][0].to('unitary')
r = 4.0*ad['virial_radius'][ad['particle_mass'] \
== ad['particle_mass'].max()][0].to('unitary')
sp = ds.sphere(pos, r)
fields = ['H_p1_density','O_p4_density','C_p0_density', 'H_density']
labels = ['HI', "OIV", "C", "H"]
## make a ray that intersects this most massive halo ##
ray = trident.make_simple_ray(ds, start_position=[pos[0], pos[1],0], end_position=[pos[0], pos[1], 1],\
lines='H')
width = ds.domain_width[0]
lbase = 1215.67
dz = ds.cosmology.z_from_t(ds.current_time-width/ds.quan(2.998*10**8, 'm/s'))
lmin = lbase*(z-dz+1)
lmax = lbase*(z+1)
sg = trident.SpectrumGenerator(lambda_min = lmin, lambda_max = lmax, dlambda=0.01)
sg.make_spectrum(ray, lines='H')
sg.save_spectrum('/home/azton/simulations/analysis/%s/spectrum_%0.3f.png'%(simname, ds.current_redshift)
for field in range(len(fields)):
prj = yt.ProfilePlot(sp, "radius",fields[field], label=labels[field]\
, weight_field='density', n_bins=100)
prj.annotate_ray(ray, arrow=True)
prj.save('/home/azton/simulations/analysis/%s/radialProfile'%simname)
# # Save plot
# slc.show()
# slc.save("YT_Test_Plots/Customization2")
##################
# 1D Profile Plots
##################
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
my_galaxy = ds.disk(ds.domain_center, [0.0, 0.0, 1.0], 10 * kpc, 3 * kpc)
# you can choose any two variables to plot.
# use weight_field to use weighted averages
# syntax ProfilePlot(dataset, x variable, y variable)
plot = yt.ProfilePlot(my_galaxy, 'density', 'temperature')
#you can plot multiple 1D plots
plot.save("YT_Test_Plots/1DProfile")
################
# 2D Phase Plots
################
# Extra keywords for stats:
# weight_field = none Total of some field in a bin; default averages values
# fractional = True Creates probability distribution fcns
# accumulation = True Cumulative distribution function, i.e. N = sum of 0 to N
phasePlot = yt.PhasePlot(ds,
"density",
"temperature", ["cell_mass"],
#plot over time
directory = "/Users/wongb/Documents/URS Data/m2_c1_16x8_64x64/More Plot Files/"
saveDirectory = "D:/URS_LargeData/SherryPlots"
conversion = 3.086e21
bounds = {
'xmin': -0.3e+22,
'xmax': 0.22e+22,
'ymin': min(ad['y']).value,
'ymax': 0
}
# bounds = {'xmin': 2.5*conversion, 'xmax': 6*conversion, 'ymin': float(min(ad['y']).value),'ymax': 0}
# bounds = {'xmin': 2.5*conversion, 'xmax': 6*conversion, 'ymin': float(min(ad['y']).value),'ymax': -1.40477660814861e21}
dsSelect = ad.include_inside('x', bounds['xmin'], bounds['xmax'])
dsSelect = dsSelect.include_inside('y', bounds['ymin'], bounds['ymax'])
dsSelect = dsSelect.cut_region("obj['temp'] > .25*10e3")
slc = yt.ProfilePlot(dsSelect, 'y', ['density'])
slc.save("YT_Test_Plots/HDF5/density_Profile2_0076")
# abc = yt.SlicePlot(ds, 'z', 'density', data_source=dsSelect,
# center=( np.sum([bounds['xmin'], bounds['xmax']])/2, np.sum([bounds['ymin'], bounds['ymax']])/2, 0))
# abc.set_width(max([ abs(bounds['xmax']-bounds['xmin']), abs(bounds['ymax']-bounds['ymin']) ]))
# abc.save("YT_Test_Plots/HDF5/TEST")
startTime = time.time()
for fileName in os.listdir(directory):
if (fileName.startswith("parkerCRs")):
ds = yt.load(directory + fileName)
print(fileName)
timeStamp = fileName[len(fileName) - 4:len(fileName)]
dsSelect = ad.include_inside('x', bounds['xmin'], bounds['xmax'])
dsSelect = dsSelect.include_inside('y', bounds['ymin'], bounds['ymax'])
dsSelect = dsSelect.cut_region("obj['temp'] > .35*10e3")
north_vector=[1, 0, 0])
H2_slice.set_zlim('H2_fraction', 1e-11, 8e-6)
H2_slice.set_cmap(field="H2_fraction", cmap='hot')
#H2_slice.save("kuvat/H2fracproj.png")
plots.append(H2_slice)
colorbar_label.append("H$_2$ Fraction")
colorbar_flags.append(True)
xaxis_flags.append(-1)
yaxis_flags.append(-1)
# H profile
val, maxTiheys = ds.find_max("density")
sphere = ds.sphere(
maxTiheys,
leveys) # keskitetään H number density -kuvaaja tiheimpään kohtaan
H_prof = yt.ProfilePlot(sphere, "radius", ["H_number_density"])
H_prof.set_unit("radius", "kpc")
H_prof.set_xlim(prof_xrange[0], prof_xrange[1])
H_prof.set_ylim("H_number_density", 0.015, 0.13)
H_prof.set_line_property("linewidth", linewidth)
H_prof.x_log = False
#H_prof.save("kuvat/Hprof.png")
plots.append(H_prof)
colorbar_flags.append(False)
xaxis_flags.append(0)
yaxis_flags.append(0)
# H2 profile
sphere = ds.sphere(
keskusta, leveys) # keskitetään H2 fraction -kuvaaja säteilylähteeseen
H2_prof = yt.ProfilePlot(sphere, "radius", ["H2_fraction"])
idx_start = args.idx_start
idx_end = args.idx_end
didx = args.didx
prefix = args.prefix
field = 'density'
center_mode = 'max'
dpi = 150
nbin = 32
yt.enable_parallelism()
ts = yt.load([
prefix + '/Data_%06d' % idx for idx in range(idx_start, idx_end + 1, didx)
])
for ds in ts.piter():
sp = ds.sphere(center_mode, 0.5 * ds.domain_width.to_value().max())
prof = yt.ProfilePlot(sp,
'radius',
field,
weight_field='cell_volume',
n_bins=nbin)
prof.set_unit('radius', 'kpc')
prof.set_xlim(5.0e-1, 1.0e2)
# prof.set_ylim( field, 1.0e-6, 1.0e0 )
prof.save(mpl_kwargs={"dpi": dpi})
def plot_standard_vcirc(sphere,
cylinder,
snap,
galaxy_name,
r_min=None,
r_max=None,
dr_factor=2,
vrot=True):
"""
Your bog standard Vcirc plot, with the option to append rotation velocities to the plot.
Requires stars, dark matter to be pre-filtered first
"""
from ramses_pp.analysis import utils, filter_utils
if r_max == None:
r_max = sphere["particle_positions_cylindrical_radius"].max().in_units(
"kpc")
# r_max = sphere.ds.arr(50,"kpc")
if r_min == None:
r_min = sphere.ds.arr(0, "kpc")
# 1) get radial values
r_indices, r_bins, r_filter, r_truths = utils.radial_indices(
'particle_position_spherical_radius',
sphere,
r_min=None,
r_max=r_max,
dr_factor=2)
ytsnap = snap.raw_snapshot()
n_bins = len(r_bins)
r_bins = ytsnap.arr(r_bins, "cmcm")
m_bins_all = utils.mass_enclosed_bins(sphere,
snap,
r_bins,
shape="sphere",
type="all")
m_bins_dark = utils.mass_enclosed_bins(sphere,
snap,
r_bins,
shape="sphere",
type="dark")
m_bins_star = utils.mass_enclosed_bins(sphere,
snap,
r_bins,
shape="sphere",
type="stars")
m_bins_gas = utils.mass_enclosed_bins(sphere,
snap,
r_bins,
shape="sphere",
type="gas")
vcirc_all = utils.vcirc(r_bins, m_bins_all, sphere)
vcirc_dark = utils.vcirc(r_bins, m_bins_dark, sphere)
vcirc_star = utils.vcirc(r_bins, m_bins_star, sphere)
vcirc_gas = utils.vcirc(r_bins, m_bins_gas, sphere)
plt.plot(r_bins.in_units("kpc"),
vcirc_all.in_units("km/s"),
color="black",
label=r"$V_{circ,all}$")
plt.plot(r_bins.in_units("kpc"),
vcirc_dark.in_units("km/s"),
color="green",
label=r"$V_{circ,dark}$")
plt.plot(r_bins.in_units("kpc"),
vcirc_star.in_units("km/s"),
color="blue",
label=r"$V_{circ,stars}$")
plt.plot(r_bins.in_units("kpc"),
vcirc_gas.in_units("km/s"),
color="red",
label=r"$V_{circ,gas}$")
plt.xlabel("Radius [kpc]")
plt.ylabel("Rotation Speed [km/s]")
if vrot:
# THE DISK SHOULD ALREADY BE FILTERED SPATIALLY KINDA
print "doing stuff with vrot"
min_z = sphere.ds.arr(-3.0, "kpc")
max_z = sphere.ds.arr(3.0, "kpc")
cold_disk = cylinder.cut_region(["obj['temperature'] < 1e4"])
# L = sphere.quantities.angular_momentum_vector(use_gas=True,use_particles=False)
# bv = sphere.get_field_parameter("bulk_velocity")
# L_mag = np.sqrt(np.power(L[0],2.0) + np.power(L[1],2.0) + np.power(L[2],2.0))
# L_norm = np.zeros(3)
# L_norm[0] = L[0].value/L_mag
# L_norm[1] = L[1].value/L_mag
# L_norm[2] = L[2].value/L_mag
# sphere.set_field_parameter("bulk_velocity",bv)
# sphere.set_field_parameter("normal",sphere.ds.arr(L_norm,"code_length"))
# cold_sphere.set_field_parameter("bulk_velocity",bv)
# cold_sphere.set_field_parameter("normal",sphere.ds.arr(L_norm,"code_length"))
add_particle_filter("young_stars",
function=young_star_filter,
filtered_type="all",
requires=["particle_age"])
cylinder.ds.add_particle_filter("young_stars")
# cold gas
print "filtering spatially"
spatial_filter_tot = filter_utils.min_max_filter(
cylinder, "particle_position_relative_z", min_z, max_z)
spatial_filter_dark = filter_utils.min_max_filter(
cylinder, ('dark', 'particle_position_relative_z'), min_z, max_z)
spatial_filter_stars = filter_utils.min_max_filter(
cylinder, ('stars', 'particle_position_relative_z'), min_z, max_z)
spatial_filter_young_stars = filter_utils.min_max_filter(
cylinder, ('young_stars', 'particle_position_relative_z'), min_z,
max_z)
r_tot = np.sqrt(
np.power(
cylinder["particle_position_relative_x"][spatial_filter_tot],
2) + np.power(
cylinder["particle_position_relative_y"]
[spatial_filter_tot], 2))
r_stars = np.sqrt(
np.power(
cylinder["stars", "particle_position_relative_x"]
[spatial_filter_stars], 2) + np.power(
cylinder["stars", "particle_position_relative_y"]
[spatial_filter_stars], 2))
r_young_stars = np.sqrt(
np.power(
cylinder["young_stars", "particle_position_relative_x"]
[spatial_filter_young_stars], 2) + np.power(
cylinder["young_stars", "particle_position_relative_y"]
[spatial_filter_young_stars], 2))
r_dark = np.sqrt(
np.power(
cylinder["dark", "particle_position_relative_x"]
[spatial_filter_dark], 2) + np.power(
cylinder["dark", "particle_position_relative_y"]
[spatial_filter_dark], 2))
# r_gas = sphere["cylindrical_r"]
# r_cold_gas = cold_sphere["cylindrical_r"]
print "computing vrots"
# vrot_tot = utils.manual_vrot(cylinder,type="all",r_filter = spatial_filter_tot)
# vrot_stars = utils.manual_vrot(cylinder,type="stars",r_filter = spatial_filter_stars)
# vrot_young_stars = utils.manual_vrot(cylinder,type="young_stars",r_filter = spatial_filter_young_stars)
# vrot_dark = utils.manual_vrot(cylinder,type="dark",r_filter = spatial_filter_dark)
vrot_stars = yt.ProfilePlot(
cylinder, ('stars', 'particle_position_cylindrical_radius'),
[('stars', 'particle_velocity_cylindrical_theta')],
weight_field=('stars', 'particle_mass'),
n_bins=n_bins,
x_log=False,
y_log={('stars', 'particle_velocity_cylindrical_theta'): False})
vrot_young_stars = yt.ProfilePlot(
cylinder, ('young_stars', 'particle_position_cylindrical_radius'),
[('young_stars', 'particle_velocity_cylindrical_theta')],
weight_field=('young_stars', 'particle_mass'),
n_bins=n_bins,
x_log=False,
y_log={
('young_stars', 'particle_velocity_cylindrical_theta'): False
})
vrot_dark = yt.ProfilePlot(
cylinder, ('dark', 'particle_position_cylindrical_radius'),
[('dark', 'particle_velocity_cylindrical_theta')],
weight_field=('dark', 'particle_mass'),
n_bins=n_bins,
x_log=False,
y_log={('dark', 'particle_velocity_cylindrical_theta'): False})
r_stars_binned = vrot_stars.profiles[0].x.in_units("kpc").value
r_young_stars_binned = vrot_young_stars.profiles[0].x.in_units(
"kpc").value
vrot_stars_binned = np.abs(vrot_stars.profiles[0][(
'stars',
'particle_velocity_cylindrical_theta')]).in_units("km/s").value
vrot_young_stars_binned = np.abs(vrot_young_stars.profiles[0][(
'young_stars',
'particle_velocity_cylindrical_theta')]).in_units("km/s").value
# this is not filtering in height yet
vrot_gas = yt.ProfilePlot(cylinder,
'cylindrical_r',
["velocity_cylindrical_theta"],
weight_field="cell_mass",
n_bins=n_bins,
x_log=False,
y_log={"velocity_cylindrical_theta": False})
r_gas = vrot_gas.profiles[0].x
vrot_gas = np.abs(vrot_gas.profiles[0]["velocity_cylindrical_theta"]
) # this overwrites the yt plot object
vrot_cold_gas = yt.ProfilePlot(
cold_disk,
'cylindrical_r', ["velocity_cylindrical_theta"],
weight_field="cell_mass",
n_bins=n_bins,
x_log=False,
y_log={"velocity_cylindrical_theta": False})
r_cold_gas = vrot_cold_gas.profiles[0].x
vrot_cold_gas = np.abs(
vrot_cold_gas.profiles[0]["velocity_cylindrical_theta"])
# bin the particle data
print "binning the data"
# r_tot_binned, vrot_tot_binned = plot_manual_profile(r_tot,vrot_tot,units=["kpc","km/s"],filter=None,bins=30,abs=True,weight_profile="ones")
# r_stars_binned, vrot_stars_binned = plot_manual_profile(r_stars,vrot_stars,units=["kpc","km/s"],filter=None,bins=30,abs=True,weight_profile="ones")
# r_dark_binned, vrot_dark_binned = plot_manual_profile(r_dark,vrot_dark,units=["kpc","km/s"],filter=None,bins=30,abs=True,weight_profile="ones")
# r_young_stars_binned, vrot_young_stars_binned = plot_manual_profile(r_young_stars,vrot_young_stars,units=["kpc","km/s"],filter=None,bins=30,abs=True,weight_profile="ones")
# make the plots look a little more pretty
r_gas, vrot_gas = flatten_line(r_gas.in_units("kpc").value,
vrot_gas.in_units("km/s").value,
no_nan=False,
extra_x=r_bins.in_units("kpc").max())
# make the plots look a little more pretty
r_cold_gas, vrot_cold_gas = flatten_line(
r_cold_gas.in_units("kpc").value,
vrot_cold_gas.in_units("km/s").value,
no_nan=False,
extra_x=r_bins.in_units("kpc").max())
r_stars_binned, vrot_stars_binned = flatten_line(
r_stars_binned,
vrot_stars_binned,
no_nan=True,
append_max=True,
double_zero=True,
extra_x=r_bins.in_units("kpc").max())
r_young_stars_binned, vrot_young_stars_binned = flatten_line(
r_young_stars_binned,
vrot_young_stars_binned,
no_nan=True,
append_max=True,
double_zero=True,
extra_x=r_bins.in_units("kpc").max())
# finally do the plots
print "plotting the data"
# plt.plot(r_dark,vrot_dark,label="vrot dark")
plt.plot(r_stars_binned,
vrot_stars_binned,
label=r"$V_{rot,stars}$",
color="blue",
linestyle='dashed')
plt.plot(r_young_stars_binned,
vrot_young_stars_binned,
label=r"$V_{rot,young stars}$",
color="purple",
linestyle='dashed')
plt.plot(r_gas,
vrot_gas,
label=r"$V_{rot,gas}$",
color="red",
linestyle='dashed')
plt.plot(r_cold_gas,
vrot_cold_gas,
label=r"$V_{rot,cold gas}$",
color="orange",
linestyle='dashed')
plt.legend()
plt.savefig(("%s_rot_circ.png" % galaxy_name))
plt.savefig(("%s_rot_circ.pdf" % galaxy_name))
plt.close()
import yt
# Load the dataset.
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
# Create a sphere of radius 100 kpc in the center of the box.
my_sphere = ds.sphere("c", (100.0, "kpc"))
# Create a profile of the average density vs. radius.
plot = yt.ProfilePlot(my_sphere, "radius", "density", weight_field="cell_mass")
# Change the units of the radius into kpc (and not the default in cgs)
plot.set_unit("radius", "kpc")
# Save the image.
# Optionally, give a string as an argument
# to name files with a keyword.
plot.save()
z_projected_angular_momentum_y.save("z_projected_angular_momentum_y.png")
z_projected_angular_momentum_x = yt.ProjectionPlot(ds,
"z",
"angular_momentum_x",
data_source=ad)
z_projected_angular_momentum_x.set_cmap(field="angular_momentum_x", cmap='bwr')
z_projected_angular_momentum_x.save("z_projected_angular_momentum_x.png")
#Velocity along z direction of z-velocity
z_projected_z_velocity = yt.ProjectionPlot(ds, "z", "velocity_z")
z_projected_z_velocity.set_cmap(field="velocity_z", cmap='bwr')
z_projected_z_velocity.save("z_velocity_density_plot.png")
#Basic Probability Density Plots
plot_1D_PDF_Density = yt.ProfilePlot(ad, "density", "ones", weight_field=None)
plot_1D_PDF_Density.save("1D_PDF_Density.png")
##############################################################################
#Analysis of Data Section
# This creates a projection weighting by density
vz = ad.integrate('velocity_z', weight='density', axis='z')
# The projection has fields 'px' and 'py' for the position.
plt.scatter(vz['px'], vz['py'], c=vz['velocity_z'])
plt.colorbar()
plt.show()
age_str = row[1]
#f = np.loadtxt(clusterdir + run + '/sm.dat', skiprows=1)
f = np.loadtxt(clusterdir + row[0] + '/sm.dat', skiprows=1)
R = f[:,0]
rho = f[:,1]
T = f[:,2]
P = f[:,3]
chks = [x.zfill(4) for x in args.chk]
for chk in chks:
#ds = yt.load(clusterdir + run + '/multitidal_hdf5_chk_' + chk)
ds = yt.load(clusterdir + row[0] + '/multitidal_hdf5_chk_' + chk)
sp = ds.sphere("c", (1.1*max(R), "cm"))
plot = yt.ProfilePlot(sp, "radius", ["density"],
weight_field="cell_mass", n_bins=2000, accumulation=False, x_log=False, y_log={'density':False})
profile = plot.profiles[0]
R_FLASH = profile.x
rho_FLASH = profile["density"]
# account for zeros in FLASH array due to binning
R_FLASH = R_FLASH[np.where(rho_FLASH > 0.)[0]]
rho_FLASH = rho_FLASH[np.where(rho_FLASH > 0.)[0]]
# prepend first density to zero. this is the density of the first cell
R_FLASH = np.insert(np.array(R_FLASH), 0, 0)
rho_FLASH = np.insert(np.array(rho_FLASH), 0, rho_FLASH[0])
fig, ax = plt.subplots()
if not args.linear:
import yt
# Load the dataset.
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
# Create a 1D profile within a sphere of radius 100 kpc
# of the average temperature and average velocity_x
# vs. density, weighted by mass.
sphere = ds.sphere("c", (100.0, "kpc"))
plot = yt.ProfilePlot(
sphere,
("gas", "density"),
[("gas", "temperature"), ("gas", "velocity_x")],
weight_field=("gas", "mass"),
)
plot.set_log(("gas", "velocity_x"), False)
# Save the image.
# Optionally, give a string as an argument
# to name files with a keyword.
plot.save()
def setUpClass(cls):
ds = fake_random_ds(16)
ad = ds.all_data()
cls.fields = ["velocity_x", "velocity_y", "velocity_z"]
cls.plot = yt.ProfilePlot(ad, "radius", cls.fields, weight_field=None)
r_max = 1.2
Const = TotM / (Disc_Decay_R -
(Disc_Decay_R + r_max) * math.exp(-r_max / Disc_Decay_R))
Const /= (2 * 3.141 * Disc_Decay_R)
yt.enable_parallelism()
ts = yt.load([
prefix + '/Data_%06d' % idx for idx in range(idx_start, idx_end + 1, didx)
])
for ds in ts.piter():
my_disk = ds.disk([1.5, 1.5, 1.5], [0., 0., 1.], (1.3, 'code_length'),
(disc_thickness, 'code_length'))
prof = yt.ProfilePlot(my_disk, ("index", "cylindrical_r"),
'ParDens',
weight_field='cell_volume',
n_bins=64,
x_log=False)
surface_dens = prof.profiles[0]["ParDens"].in_units(
"code_mass/(code_length*code_length*code_length)").d
surface_dens *= disc_thickness
logSurDens = np.log10(surface_dens)
radius = prof.profiles[0].x.in_units("code_length").d
sumM = 2 * 3.1416 * radius * 1.3 / 64 * surface_dens
print('TotM=', np.sum(sumM))
# print('Sur=',surface_dens)
# print('log=',logSurDens)
# coefficient = np.polyfit(radius[0:-4],logSurDens[0:-4],1)
# print(coefficient)
# print(my_disk.quantities.total_mass())
def find_galaxyprops(galaxy_props, ds, hc_sphere, max_ndens_arr):
print('Determining stellar and gas mass...')
# Get total stellar mass
stars_mass = hc_sphere[('stars', 'particle_mass')].in_units('Msun')
stars_total_mass = stars_mass.sum().value[()]
galaxy_props['stars_total_mass'] = np.append(
galaxy_props['stars_total_mass'], stars_total_mass)
# Get total mass of gas
gas_mass = hc_sphere[('gas', 'cell_mass')].in_units('Msun')
gas_total_mass = gas_mass.sum().value[()]
galaxy_props['gas_total_mass'] = np.append(galaxy_props['gas_total_mass'],
gas_total_mass)
print('\tlog Mgas/Msun = ', log10(gas_total_mass))
print('\tlog M*/Msun = ', log10(stars_total_mass))
print('Determining location of max stellar density...')
# Get max density of stars (value, location)
stars_maxdens = hc_sphere.quantities.max_location(('deposit', 'stars_cic'))
stars_maxdens_val = stars_maxdens[0].in_units('Msun/kpc**3').value[()]
print(stars_maxdens)
#difference bt yt-3.2.3 and yt-3.3dev: stars_maxdens has different # elements; this works for both
stars_maxdens_loc = np.array([
stars_maxdens[-3].in_units('kpc').value[()],
stars_maxdens[-2].in_units('kpc').value[()],
stars_maxdens[-1].in_units('kpc').value[()]
])
galaxy_props['stars_maxdens'].append(
(stars_maxdens_val, stars_maxdens_loc))
print('\t Max Stellar Density = ', stars_maxdens_loc)
print('Determining location of max gas density...')
# Get max density of gas
gas_maxdens = hc_sphere.quantities.max_location(('gas', 'density'))
gas_maxdens_val = gas_maxdens[0].in_units('Msun/kpc**3').value[()]
gas_maxdens_loc = np.array([
gas_maxdens[-3].in_units('kpc').value[()],
gas_maxdens[-2].in_units('kpc').value[()],
gas_maxdens[-1].in_units('kpc').value[()]
])
galaxy_props['gas_maxdens'].append((gas_maxdens_val, gas_maxdens_loc))
print('\t Max Gas Density = ', stars_maxdens_loc)
print('Determining refined histogram center of stars...')
#---Need to Check these--#
# Get refined histogram center of stars
stars_pos_x = hc_sphere[('stars', 'particle_position_x')].in_units('kpc')
stars_pos_y = hc_sphere[('stars', 'particle_position_y')].in_units('kpc')
stars_pos_z = hc_sphere[('stars', 'particle_position_z')].in_units('kpc')
stars_pos = np.array([stars_pos_x, stars_pos_y, stars_pos_z]).transpose()
stars_hist_center = find_hist_center(stars_pos, stars_mass)
galaxy_props['stars_hist_center'].append(stars_hist_center)
print('\t Refined histogram center of stars = ', stars_hist_center)
print('Computing stellar density profile...')
# Get stellar density profile
sc_sphere_r = 0.1
ssphere_r = sc_sphere_r * hc_sphere.radius
while ssphere_r < ds.index.get_smallest_dx():
ssphere_r = 2.0 * ssphere_r
sc_sphere = ds.sphere(max_ndens_arr, ssphere_r)
try:
p_plot = yt.ProfilePlot(sc_sphere,
'radius',
'stars_mass',
n_bins=50,
weight_field=None,
accumulation=True)
p_plot.set_unit('radius', 'kpc')
p_plot.set_unit('stars_mass', 'Msun')
p = p_plot.profiles[0]
radii, smass = p.x.value, p['stars_mass'].value
rhalf = radii[smass >= 0.5 * smass.max()][0]
except (IndexError, ValueError): # not enough stars found
radii, smass = None, None
rhalf = None
galaxy_props['stars_rhalf'] = np.append(galaxy_props['stars_rhalf'], rhalf)
galaxy_props['stars_mass_profile'].append((radii, smass))
print('\tStars half-light radius = ', rhalf)
print('Determining center of mass within 15 kpc of the galaxy...')
# Get center of mass of stars
gal_sphere = ds.sphere(max_ndens_arr, (15, 'kpc'))
stars_pos_x = gal_sphere[('stars', 'particle_position_x')].in_units('kpc')
stars_pos_y = gal_sphere[('stars', 'particle_position_y')].in_units('kpc')
stars_pos_z = gal_sphere[('stars', 'particle_position_z')].in_units('kpc')
gal_stars_mass = gal_sphere[('stars', 'particle_mass')].in_units('Msun')
gal_total_mass = gal_stars_mass.sum().value[()]
stars_com = np.array([
np.dot(stars_pos_x, gal_stars_mass) / gal_total_mass,
np.dot(stars_pos_y, gal_stars_mass) / gal_total_mass,
np.dot(stars_pos_z, gal_stars_mass) / gal_total_mass
])
galaxy_props['stars_com'].append(stars_com)
print('\tCenter of mass = ', stars_com)
print('Setting stars center...')
# Define center of stars
center = 'maxndens'
if center == 'max_dens':
stars_center = stars_maxdens_loc
elif center == 'com':
stars_center = stars_com
elif center == 'maxndens':
stars_center = max_ndens_arr
else:
stars_center = stars_hist_center
stars_center = ds.arr(stars_center, 'kpc')
galaxy_props['stars_center'].append(stars_hist_center)
print('\tStars Center = ', stars_center)
# Get angular momentum of stars
try:
x, y, z = [
sc_sphere[('stars', 'particle_position_%s' % s)] for s in 'xyz'
]
vx, vy, vz = [
sc_sphere[('stars', 'particle_velocity_%s' % s)] for s in 'xyz'
]
mass = sc_sphere[('stars', 'particle_mass')]
try:
metals = sc_sphere[('stars', 'particle_metallicity1')]
stars_L = L_crossing(x, y, z, vx, vy, vz, mass * metals,
sc_sphere.center)
except:
stars_L = L_crossing(x, y, z, vx, vy, vz, mass, sc_sphere.center)
except IndexError: # no stars found
stars_L = [None, None, None]
print("No stars exception")
galaxy_props['stars_L'].append(stars_L)
del (sc_sphere)
# Get angular momentum of gas
gas_center = ds.arr(gas_maxdens_loc, 'kpc')
gc_sphere = ds.sphere(gas_center, ssphere_r)
x, y, z = [gc_sphere[('gas', '%s' % s)] for s in 'xyz']
cell_volume = gc_sphere[('gas', 'cell_volume')]
try:
#for VELA runs
vx, vy, vz = [gc_sphere[('gas', 'momentum_%s' % s)]
for s in 'xyz'] # momentum density
metals = gc_sphere[('gas', 'metal_ia_density')] + gc_sphere[
('gas', 'metal_ii_density')]
gas_L = L_crossing(x, y, z, vx, vy, vz, metals * cell_volume**2,
gc_sphere.center)
except:
#for enzo runs
density = gc_sphere[('gas', 'density')]
vx, vy, vz = [gc_sphere[('gas', 'velocity_%s' % s)] for s in 'xyz']
metals = gc_sphere[('gas', 'metal_density')]
gas_L = L_crossing(x, y, z, density * vx, density * vy, density * vz,
metals * cell_volume**2, gc_sphere.center)
galaxy_props['gas_L'].append(gas_L)
del (gc_sphere)
return galaxy_props
import yt
# Load the dataset.
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
# Create a sphere of radius 100 kpc in the center of the box.
my_sphere = ds.sphere("c", (100.0, "kpc"))
# Create a profile of the average density vs. radius.
plot = yt.ProfilePlot(
my_sphere,
("index", "radius"),
("gas", "density"),
weight_field=("gas", "cell_mass"),
)
# Change the units of the radius into kpc (and not the default in cgs)
plot.set_unit(("index", "radius"), "kpc")
# Save the image.
# Optionally, give a string as an argument
# to name files with a keyword.
plot.save()
def yt_inline_ProfilePlot():
ds = yt.frontends.libyt.libytDataset()
profile = yt.ProfilePlot(ds, "x", ["density"])
if yt.is_root():
profile.save()
import yt
# Load the dataset.
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
# Create a 1D profile within a sphere of radius 100 kpc
# of the average temperature and average velocity_x
# vs. density, weighted by mass.
sphere = ds.sphere("c", (100.0, "kpc"))
plot = yt.ProfilePlot(sphere,
"density", ["temperature", "velocity_x"],
weight_field="cell_mass")
plot.set_log("velocity_x", False)
# Save the image.
# Optionally, give a string as an argument
# to name files with a keyword.
plot.save()
#output = int(sys.argv[1])
output = 3035
ds = ytf.load_romulusC(output)
cen = rom_help.get_romulus_yt_center('romulusC', output, ds)
ad = ds.sphere(cen, (3300, 'kpc'))
#sp = ad.cut_region(["(obj[('gas', 'metal_cooling_time')]>0) & (obj[('gas', 'metal_primordial_cooling_time_ratio')] > 0) & (obj[('gas', 'temperature')] >= 1e4) & (obj[('gas', 'temperature')] <= 1e6) & (obj[('gas', 'particle_H_nuclei_density')] > 1e-6) & (obj[('gas', 'particle_H_nuclei_density')] < 1e-2)"])
sp = ad.cut_region(["(obj[('gas', 'temperature')] >= 1e4) & (obj[('gas', 'temperature')] <= 1e6) & (obj[('gas', 'particle_H_nuclei_density')] > 1e-6) & (obj[('gas', 'particle_H_nuclei_density')] < 1e-2)"])
#sp = ad
xfield = ('gas', 'spherical_position_radius')
yfield = ('Gas', 'Mass')
#mass enclosed needs to have all mass, not just CGM mass
pm = yt.ProfilePlot(ad, xfield, yfield, weight_field = None, accumulation = True, n_bins = 128)
pm.set_unit(xfield, 'cm')
pm.set_unit(yfield, 'g')
pm.set_log(xfield, False)
profile = pm.profiles[0]
rbins = profile.x
print(rbins)
mass_enc = profile[yfield]
G = YTQuantity(6.67e-8, 'cm**3/g/s**2')
num = np.pi * rbins**(3./2.)
denom = np.sqrt(2*G*mass_enc)
tff2 = num / denom
g = G*mass_enc / rbins**2
def vrot(datadict,
field_labels,
ytdataset,
fields=["stars", "young_stars", "disk_stars", "gas", "cold_gas"],
n_bins=50,
AMR=True,
manual=False):
"""
Input
ytdataset: A ytdataset with gas cells or gas particles.
particulally of the region you want to work with (e.g a disk)
fields: list of fields to compute vrot for
output
r_bins_list = list of r)bins in kpc
"""
vrot_list = []
rbins_list = []
r_max = ytdataset["particle_position_cylindrical_radius"].max().in_units(
"kpc")
r_indices, r_bins, r_filter, r_truths = utils.radial_indices(
'particle_position_spherical_radius',
ytdataset,
r_min=None,
r_max=r_max,
dr_factor=2)
for field in fields:
if field == "gas" and AMR == True:
vrot = yt.ProfilePlot(ytdataset,
'cylindrical_r',
["velocity_cylindrical_theta"],
weight_field="cell_mass",
n_bins=n_bins,
x_log=False,
y_log={"velocity_cylindrical_theta": False})
r_binned = vrot.profiles[0].x.in_units("kpc").value
vrot_binned = -vrot.profiles[0][
"velocity_cylindrical_theta"].in_units(
"km/s").value # this overwrites the yt plot object
elif field == "cold_gas" and AMR == True:
cold_disk = ytdataset.cut_region(["obj['temperature'] < 1e4"])
vrot = yt.ProfilePlot(cold_disk,
'cylindrical_r',
["velocity_cylindrical_theta"],
weight_field="cell_mass",
n_bins=n_bins,
x_log=False,
y_log={"velocity_cylindrical_theta": False})
r_binned = vrot.profiles[0].x.in_units("kpc").value
vrot_binned = -vrot.profiles[0][
"velocity_cylindrical_theta"].in_units("km/s").value
else:
if manual == False:
# vrot = yt.create_profile(ytdataset,[(field,'particle_position_cylindrical_radius')],[(field,'particle_velocity_cylindrical_theta')],logs={"particle_position_cylindrical_radius":False, 'particle_velocity_cylindrical_theta':False}, weight_field='particle_mass')
# r_binned = vrot.x.in_units("kpc").value
# vrot_binned = vrot[(field,'particle_velocity_cylindrical_theta')].in_units("km/s").value
#vrot = yt.ProfilePlot(ytdataset,(field,'particle_position_cylindrical_radius'),[(field,'particle_velocity_cylindrical_theta')],weight_field=(field,'particle_mass'),n_bins=n_bins,x_log=False,y_log={(field,'particle_velocity_cylindrical_theta'):False})
vrot = yt.ProfilePlot(
ytdataset, (field, 'particle_position_cylindrical_radius'),
[(field, 'particle_vtheta')],
weight_field=(field, 'particle_mass'),
n_bins=n_bins,
x_log=False,
y_log={(field, 'particle_vtheta'): False})
r_binned = vrot.profiles[0].x.in_units("kpc").value
vrot_binned = -vrot.profiles[0][
(field, 'particle_vtheta')].in_units("km/s").value
else:
# # manual profile plot
hist, bins = np.histogram(
ytdataset[field,
'particle_position_cylindrical_radius'].in_units(
"kpc").value,
bins=n_bins)
print hist, bins, field
inds = np.digitize(
ytdataset[field,
'particle_position_cylindrical_radius'].in_units(
"kpc").value,
bins=bins)
# shifts down to index 0
inds = inds - 1
# include the max values in the last bin
inds[np.argmax(inds)] = inds.max() - 1
width = (bins[:-1] + bins[1:]) / 2.0
# #time = time[:i1]
# want to compute the mass weight ... vrot * mass_i / mass_mean in each bin
# average of sum of (vrot * mass_i) / mass_tot
#vrot_thing = np.array([ np.sum(ytdataset[field,"particle_velocity_cylindrical_theta"][inds == j].in_units("km/s").value * ytdataset[field,"particle_mass"][inds == j].in_units("Msun").value) for j in range(len(bins))])
vrot_thing = np.array([
np.sum(ytdataset[field, "particle_vtheta"][
inds == j].in_units("km/s").value *
ytdataset[field, "particle_mass"][
inds == j].in_units("Msun").value)
for j in range(len(bins))
])
vrot_binned = vrot_thing / np.array(
[(ytdataset[field, "particle_mass"][inds == j].in_units(
"Msun").value).sum() for j in range(len(bins))])
#
# #vrot_binned[vrot_binned == 0] = np.nan
vrot_binned[vrot_binned == np.nan] = 0.0
vrot_binned = abs(vrot_binned)
#
r_binned = bins
# make things pretty
# r_binned, vrot_binned = flatten_line(r_binned,vrot_binned,no_nan=True,append_max=True,double_zero=True,extra_x = r_bins.in_units("kpc").max())
datadict.update({
"vrot_r_%s" % field: r_binned,
"vrot_v_%s" % field: vrot_binned,
})
field_labels.update({
"vrot_r_%s" % field: ("Radius ( kpc )", None),
"vrot_v_%s" % field: ("Rotational Velocity ( km/s )",
r"$V_{rot,%s}$" % field.replace("_", " ")),
})
return datadict, field_labels
