def plot_series(ts):
for sto, ds in ts.piter(storage=storage):
for z in z_fields:
for xy in xy_fields:
ad = ds.all_data()
outflow_criteria = hot_domain + a + high_Z + a + pos_Vr
inflow_criteria = low_Z + a + cold_domain + a + neg_Vr
outflow_region = ad.cut_region([outflow_criteria])
inflow_region = ad.cut_region([inflow_criteria])
cgm_region = ad - outflow_region - inflow_region
for region in regions.keys():
if (xy[0] == 'radius'):
pp = yt.PhasePlot(regions.get(region),
xy[0],
xy[1],
'entropy',
weight_field=None)
else:
pp = yt.PhasePlot(regions.get(region),
xy[0],
xy[1],
z,
weight_field=None)
x_and_y_fields = xy[0] + '_vs_' + xy[1]
path = "%s/%s/%s" % (region, z, x_and_y_fields)
#pp.set_zlim(z, 1e-1, 1e5)
#pp.set_log(z, False)
pp.annotate_title(region)
pp.set_cmap(z, "kamae")
#print('dataset: %s' % ds)
pp.save(path + "_%s" % ds)
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_phase():
es = sim_dir_load(_pf_name, path=_dir_name)
es.get_time_series(redshifts=[0])
ds = es[-1]
ad = ds.all_data()
profile = ad.profile([("gas", "density")], [("gas", "temperature"),
("gas", "cell_mass")])
profile1 = ad.profile([("gas", "density")], [("gas", "temperature"),
("gas", "cooling_time")],
weight_field=('gas', 'cell_mass'))
density = profile.x
temperature = profile[('gas', 'temperature')]
cooling_time = profile1[('gas', 'cooling_time')]
cell_mass = profile[('gas', 'cell_mass')]
filename = 'phase_data.h5'
save_filename = os.path.join(_dir_name, filename)
data = {
('data', 'density'): density,
('data', 'temperature'): temperature,
('data', 'cooling_time'): cooling_time,
('data', 'cell_mass'): cell_mass
}
yt.save_as_dataset(ds, save_filename, data)
pp = yt.PhasePlot(ad, ('gas', 'density'), ('gas', 'temperature'),
('gas', 'cell_mass'))
pp.set_unit(('gas', 'cell_mass'), 'Msun')
pp.save(_dir_name)
pp1 = yt.PhasePlot(ad, ('gas', 'density'), ('gas', 'temperature'),
('gas', 'cooling_time'),
weight_field=('gas', 'cell_mass'))
pp1.save(_dir_name)
compare_filename = os.path.join(test_data_dir, filename)
if generate_answers:
os.rename(save_filename, compare_filename)
return
# do the comparison
ds_comp = yt.load(compare_filename)
# assert quality to 8 decimals
assert_rel_equal(data[('data', 'density')],
ds_comp.data[('data', 'density')], 8)
assert_rel_equal(data[('data', 'temperature')],
ds_comp.data[('data', 'temperature')], 8)
assert_rel_equal(data[('data', 'cooling_time')],
ds_comp.data[('data', 'cooling_time')], 8)
assert_rel_equal(data[('data', 'cell_mass')],
ds_comp.data[('data', 'cell_mass')], 8)
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):
source = self.parent.active_data_object.data
x_field = self.x_field.get_field()
y_field = self.y_field.get_field()
z_field = self.z_field.get_fields()
weight_field = self.weight_field.get_field()
if weight_field[0] == 'None':
weight_field = None
elif weight_field[0] == 'Default':
weight_field = 'cell_mass'
x_bins = self.x_bins.value()
y_bins = self.y_bins.value()
accumulation = self.accumulation.currentText() == 'True'
fractional = self.fractional.currentText() == 'True'
fontsize = self.fontsize.value()
plot = yt.PhasePlot(source,
x_field,
y_field,
z_field,
weight_field=weight_field,
x_bins=x_bins,
y_bins=y_bins,
accumulation=accumulation,
fractional=fractional,
fontsize=fontsize)
view = PlotWindowView(plot)
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_unequal_bin_field_profile(self):
density = np.random.random(128)
temperature = np.random.random(127)
mass = np.random.random((128, 128))
my_data = {
("gas", "density"): density,
("gas", "temperature"): temperature,
("gas", "mass"): mass,
}
fake_ds_med = {"current_time": yt.YTQuantity(10, "Myr")}
field_types = {field: "gas" for field in my_data.keys()}
yt.save_as_dataset(fake_ds_med,
"mydata.h5",
my_data,
field_types=field_types)
ds = yt.load("mydata.h5")
with assert_raises(YTProfileDataShape):
yt.PhasePlot(
ds.data,
("gas", "temperature"),
("gas", "density"),
("gas", "mass"),
)
def test_phaseplot_showhide_colorbar_axes():
fields = ('density', 'temperature')
units = ('g/cm**3', 'K',)
ds = fake_random_ds(16, fields=fields, units=units)
ad = ds.all_data()
plot = yt.PhasePlot(ad, ("gas", "density"), ("gas", "temperature"), "cell_mass")
# make sure we can hide colorbar
plot.hide_colorbar()
with tempfile.NamedTemporaryFile(suffix='png') as f1:
plot.save(f1.name)
# make sure we can show colorbar
plot.show_colorbar()
with tempfile.NamedTemporaryFile(suffix='png') as f2:
plot.save(f2.name)
# make sure we can hide axes
plot.hide_axes()
with tempfile.NamedTemporaryFile(suffix='png') as f3:
plot.save(f3.name)
# make sure we can show axes
plot.show_axes()
with tempfile.NamedTemporaryFile(suffix='png') as f4:
plot.save(f4.name)
def PhasePlot(Param_Dict, worker):
"""Takes a DataSet object loaded with yt and performs a phasePlot on it.
Parameters:
Param_Dict: to access the relevant parameters
"""
if Param_Dict["WeightField"] is None:
GUILogger.warning('Having <font color="DarkViolet">None</font> as the '
"weight field just accumulates, "
"so the extrema might be inaccurate.")
ds = Param_Dict["CurrentDataSet"]
XField, YField, ZField = Param_Dict["XAxis"], Param_Dict["YAxis"], \
Param_Dict["ZAxis"]
ad = ds.all_data()
if Param_Dict["ParticlePlot"]:
plot = yt.ParticlePhasePlot(ad, XField, YField, ZField,
weight_field=Param_Dict["WeightField"],
fontsize=14)
else:
plot = yt.PhasePlot(ad, XField, YField, ZField,
weight_field=Param_Dict["WeightField"],
fontsize=14)
emitStatus(worker, "Setting phase plot modifications")
# Set min, max, unit log and color scheme:
setAxisSettings(plot, Param_Dict, "X")
setAxisSettings(plot, Param_Dict, "Y")
setAxisSettings(plot, Param_Dict, "Z")
emitStatus(worker, "Annotating the phase plot")
plot.annotate_title(Param_Dict["PlotTitle"])
finallyDrawPlot(plot, Param_Dict, worker)
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 phase_plots(ds, to_plot = 'all', region = None):
# construct a list of phase diagrams here. List contains list of tuples, where each
# list is the following set of 4 items: [ x-axis field, y-axis field, cbar field, weight_field ]
#
pp_def = { 'T_n' : [ ('gas','number_density'), ('enzo','Temperature'), ('gas','cell_mass'), None],
'T_n_Fe' : [ ('gas','number_density'), ('enzo','Temperature'), ('gas','Fe_Mass'), None],
'T_n_O' : [ ('gas','number_density'), ('enzo','Temperature'), ('gas','O_Mass'), None],
'T_n_C' : [ ('gas','number_density'), ('enzo','Temperature'), ('gas','C_Mass'), None],
'P_T' : [ ('enzo','Temperature'), ('gas','pressure'), ('gas', 'cell_mass'), None],
'Go_n' : [ ('gas','number_density'), ('gas','G_o'), ('gas','cell_mass'), None],
'Go_r' : [ ('index','magnitude_cylindrical_radius'), ('gas','G_o'), ('gas','cell_mass'), None]
}
pdict = {}
if to_plot == 'all':
for n in ['T_n_Fe','T_n_O','T_n','P_T','Go_n','T_n_C']:
pdict[n] = pp_def[n]
if region is None:
region = ds.all_data()
#print(cbar_lim)
for name in pdict:
pdef = pdict[name]
pp = yt.PhasePlot( region, pdef[0], pdef[1], pdef[2],
weight_field = pdef[3])
if pdef[0] == ('gas','magnitude_cylindrical_radius'):
pp.set_log('magnitude_cylindrical_radius', False)
# set units on each axis
for f in pdef[:3]:
pp.set_unit(f[1], field_units[f].units)
# set plot limits for horizonatal and vertical axes
if not plim[pdef[0]] is None:
pp.set_xlim(plim[pdef[0]][0], plim[pdef[0]][1])
if not plim[pdef[1]] is None:
pp.set_ylim(plim[pdef[1]][0], plim[pdef[1]][1])
# set color map limits
#print((cbar_lim[pdef[2]], pdef[2]))
if not (cbar_lim[pdef[2]] is None):
pp.set_zlim( pdef[2], cbar_lim[pdef[2]][0], cbar_lim[pdef[2]][1])
pp.set_cmap( pdef[2], 'cubehelix')
pp.save('./phase_plots/')
del(pp)
return
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 plot_phase(output, sim, tctf, beta_list, cr_list, diff_list, stream_list,
heat_list, title_list):
cmap_list = [palettable.cmocean.sequential.Tempo_20.mpl_colormap]
ncols = int(len(cr_list) / 2)
nrows = 2
fig, ax = plt.subplots(ncols=ncols,
nrows=nrows,
figsize=(4 * ncols, 4.4 * nrows))
for i, cr in enumerate(cr_list):
sim_loc = pt.get_sim_location(sim, tctf, beta_list[i], cr, \
diff = diff_list[i], stream = stream_list[i], heat = heat_list[i], work_dir = workdir)
ds = ytf.load('%s/DD%04d/DD%04d' % (sim_loc, output, output))
ad = ds.all_data()
ad_cut = ad.cut_region([
"(obj[('gas', 'z')].in_units('kpc') > 4.3) | (obj[('gas', 'z')].in_units('kpc') < -4.3)"
])
ph = yt.PhasePlot(ad_cut, ('gas', 'density'), ('gas', 'temperature'), ('gas', 'cell_mass'),\
weight_field = None, fractional = True)
ph.save()
prof = ph.profile
xbins = prof.x
ybins = prof.y
data = prof[('gas', 'cell_mass')].T
print(xbins, ybins, data)
vmin = 1e-5
vmax = 1e-2
cmap = cmap_list[0]
cmap = palettable.cubehelix.jim_special_16_r.mpl_colormap
row = int(i / ncols)
col = i - row * ncols
print(i, row, col)
ax[row][col].set_xscale('log')
ax[row][col].set_yscale('log')
ax[row][col].set_xlim(1.5e-28, 8e-26)
ax[row][col].set_ylim(4e4, 1e7)
pcm = ax[row][col].pcolormesh(xbins, ybins, data, norm = LogNorm(), cmap = cmap, \
vmax = vmax, vmin = vmin)
ax[row][col].set_title(title_list[i], fontsize=16)
ax[row][col].set_xlabel('Density (g cm$^{-3}$)')
ax[row][col].set_ylabel('Temperature (K)')
figname = '../../plots/production/phase_density_temperature_mass_%s_tctf_%.1f_cr_%.2f_%.1f.png' % (
sim, tctf, cr, output)
fig.tight_layout()
print(figname)
plt.savefig(figname, dpi=300)
def plot_phase(output, folder='.'):
cmap_list = [palettable.cmocean.sequential.Tempo_20.mpl_colormap]
ncols = int(len(cr_list) / 2)
nrows = 2
fig, ax = plt.subplots(ncols=ncols,
nrows=nrows,
figsize=(4 * ncols, 4.4 * nrows))
for i, cr in enumerate(cr_list):
sim_loc = pt.get_sim_location(sim, tctf, beta_list[i], cr, \
diff = diff_list[i], stream = stream_list[i], heat = heat_list[i])
ds = ytf.load('%s/DD%04d/DD%04d' % (sim_loc, output, output))
ad = ds.all_data()
ph = yt.PhasePlot(ad, ('gas', 'temperature'), ('gas', 'cr_eta'), ('gas', 'cell_mass'),\
weight_field = None, fractional = True)
ph.set_ylim(cr / 1e3, cr * 1e3)
prof = ph.profile
xbins = prof.x
ybins = prof.y
data = prof[('gas', 'cell_mass')].T
vmin = 1e-5
vmax = 1e-2
cmap = cmap_list[0]
cmap = palettable.cubehelix.jim_special_16_r.mpl_colormap
row = int(i / ncols)
col = i - row * ncols
print(i, row, col)
ax[row][col].set_xscale('log')
ax[row][col].set_yscale('log')
# ax[row][col].set_xlim(1.5e-28, 8e-26)
ax[row][col].set_xlim(4e4, 1e7)
pcm = ax[row][col].pcolormesh(xbins, ybins, data, norm = LogNorm(), cmap = cmap, \
vmax = vmax, vmin = vmin)
ax[row][col].set_title(title_list[i], fontsize=16)
# ax[row][col].set_ylabel('Density (g cm$^{-3}$)')
ax[row][col].set_ylabel('CR Pressure / Gas Pressure')
ax[row][col].set_xlabel('Temperature (K)')
figname = '../../plots/phase_temperature_cr_eta_tctf_%.1f_%.1f.png' % (
tctf, output)
# if diff > 0:
# figname = '../../plots/phase_temperature_cr_eta_mass_tctf_%.1f_cr_diff_%.1f_%.1f.png'%(tctf, diff, output)
fig.tight_layout()
print(figname)
plt.savefig(figname, dpi=300)
def plot_timestep(ds):
for z in z_fields:
for xy in xy_fields:
ad = ds.all_data()
center = [0.5, 0.5, 0.5]
inner_sp = ds.sphere(center, (50, 'Mpc'))
outer_sp = ds.sphere(center, (300, 'Mpc'))
outer_shell = outer_sp - inner_sp
outer_shell_domain = ad.cut_region([outer_shell])
outflow_domain = ad.cut_region([outflow])
inflow_domain = ad.cut_region([inflow])
cgm_domain = ad.cut_region([CGM])
regions = {
'outflow_domain': outflow_domain,
'inflow_domain': inflow_domain,
'cgm_domain': cgm_domain
}
#regions = {'inflow_domain': inflow_domain}
for region in regions.keys():
if (xy[0] == 'radius'):
pp = yt.PhasePlot(regions.get(region),
xy[0],
xy[1],
'entropy',
weight_field=None)
else:
pp = yt.PhasePlot(regions.get(region),
xy[0],
xy[1],
z,
weight_field=None)
x_and_y_fields = xy[0] + '_vs_' + xy[1]
path = "%s/%s/%s" % (region, z, x_and_y_fields)
#pp.set_zlim(z, 1e-1, 1e5)
pp.annotate_title(region)
pp.set_cmap(z, "kamae")
pp.save(path + "_%s" % ds)
def test_set_linear_scaling_for_none_extrema(self):
# See Issue #3431
# Ensures that extrema are calculated in the same way on subsequent passes
# through the PhasePlot machinery.
ds = fake_sph_orientation_ds()
p = yt.PhasePlot(
ds,
("all", "particle_position_spherical_theta"),
("all", "particle_position_spherical_radius"),
("all", "particle_mass"),
weight_field=None,
)
p.set_log(("all", "particle_position_spherical_theta"), False)
p.save()
def make_phase(ds, data_source):
"""
"""
ph = yt.PhasePlot(data_source, 'density', 'temperature', ['mass'], weight_field=None)
ph.set_log('density', True)
ph.set_unit('density', 'g/cm**3')
ph.set_log('temperature', True)
ph.set_unit('temperature', 'K')
ph.set_xlim(1e-30,1e-20)
ph.set_ylim(1e1,1e7)
ph.set_cmap('mass', 'dusk')
ph.set_unit('mass', 'Msun')
ph.set_zlim('mass', 5e4,5e8)
ph.save('images/')
def get_ion_plots(ds, halo_center, ray):
line_list = ['H', 'O'] # 'C', 'N', 'Si', 'O']
for axis in ['z','y','x']:
p = yt.ProjectionPlot(ds, axis, 'density', center=halo_center, width=(500,'kpc'))
p.annotate_ray(ray, arrow=True)
p.annotate_grids()
p.save()
p = yt.SlicePlot(ds, axis, 'metallicity', center=halo_center, width=(500,'kpc'))
p.annotate_ray(ray, arrow=True)
p.annotate_grids()
p.save()
proj = yt.SlicePlot(ds, axis, "O_p5_number_density", center=halo_center, width=(500,'kpc'))
p.annotate_grids()
proj.save('OVI_Slice')
# O VI map?
p = yt.ProjectionPlot(ds, axis, 'O_p5_number_density', center=halo_center, width=(500,'kpc'))
p.annotate_grids()
p.save('OVI_Column')
proj = yt.SlicePlot(ds, axis, "H_p0_number_density", center=halo_center, width=(500,'kpc'))
proj.save('HI')
p = yt.ProjectionPlot(ds, axis, 'H_p0_number_density', center=halo_center, width=(500,'kpc'))
p.annotate_grids()
p.save('HI_Column')
proj = yt.SlicePlot(ds, axis, "Si_p2_number_density", center=halo_center, width=(500,'kpc'))
p.annotate_grids()
proj.save('SiIII_Column')
sph = ds.sphere(center=halo_center, radius=(500,'kpc'))
phase = yt.PhasePlot(sph, "density", "temperature", ["O_p5_mass"], weight_field="O_p5_mass", fractional=True)
phase.save()
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
def mach_number(
path,
idx_start=1,
idx_end=100,
didx=1,
):
ts = yt.load([
path + '/Data_%06d' % idx
for idx in range(idx_start, idx_end + 1, didx)
])
ds = yt.load(path + '/Data_000001')
cg = ds.covering_grid(0, left_edge=[0.0, 0.0, 0.0], dims=[256, 256, 256])
cg.get_data(["density", "mach_number", "cell_mass"])
density_data = cg["density"]
mach_number_data = cg["mach_number"]
cell_mass_data = cg["cell_mass"]
dens_min = density_data.min()
dens_max = density_data.max()
mach_min = mach_number_data.min()
mach_max = mach_number_data.max()
cell_min = cell_mass_data.min()
cell_max = cell_mass_data.max()
for ds in ts.piter():
ad = ds.all_data()
plot = yt.PhasePlot(ad,
"density",
"mach_number", ["cell_mass"],
weight_field=None)
plot.set_xlim(dens_min, dens_max)
plot.set_ylim(mach_min, mach_max)
plot.set_zlim("cell_mass", cell_min, cell_max)
plot.save(name=path + '/images/' + str(ds))
import yt
# Load the dataset.
ds = yt.load("GalaxyClusterMerger/fiducial_1to3_b0.273d_hdf5_plt_cnt_0175")
# Create a data object that represents the whole box.
ad = ds.all_data()
# This is identical to the simple phase plot, except we supply
# the fractional=True keyword to divide the profile data by the sum.
plot = yt.PhasePlot(ad,
"density",
"temperature",
"mass",
weight_field=None,
fractional=True)
# Save the image.
# Optionally, give a string as an argument
# to name files with a keyword.
plot.save()
def make_plots(ds, c, boxside):
box = ds.box(c - boxside, c + boxside)
c = ds.arr(c, 'code_length')
basename = ds.basename + "_nref" + str(
ds.get_parameter('MaximumRefinementLevel'))
width = (197. / ds.hubble_constant) / (1 + ds.current_redshift)
print "width = ", width, "kpc"
# for axis in ("x", "y", "z"):
if False:
for axis in ("y"):
dpy = yt.ProjectionPlot(ds,
axis, ('gas', 'density'),
center=c,
width=(width, "kpc"),
data_source=box)
cmap = sns.blend_palette(
("black", "#984ea3", "#d73027", "darkorange", "#ffe34d",
"#4daf4a", "white"),
n_colors=60,
as_cmap=True)
dpy.set_zlim(("gas", "density"), 5e-2, 1e4)
dpy.set_cmap(("gas", "density"), cmap)
dpy.annotate_scale(size_bar_args={'color': 'white'})
dpy.hide_axes()
dpy.set_unit(('gas', 'density'), 'Msun/pc**2')
plotname = dpy.save()
newname = plotname[0].replace(ds.basename, basename)
os.rename(plotname[0], newname)
if True:
dty = yt.ProjectionPlot(ds,
axis, ('gas', 'temperature'),
weight_field=("gas", "density"),
center=c,
width=(width, "kpc"),
data_source=box)
dty.set_zlim(("gas", "temperature"), 1e3, 6e5)
cmap = sns.blend_palette(
("black", "#d73027", "darkorange", "#ffe34d"),
n_colors=50,
as_cmap=True)
dty.set_cmap(("gas", "temperature"), cmap)
plotname = dty.save()
newname = plotname[0].replace(ds.basename, basename)
os.rename(plotname[0], newname)
dpz = yt.ProjectionPlot(ds,
axis, ('gas', 'metallicity'),
weight_field=("gas", "density"),
center=c,
width=(width, "kpc"),
data_source=box)
dpz.set_zlim(("gas", "metallicity"), 0.005, 1.5)
cmap = sns.blend_palette(("black", "#984ea3", "#4575b4",
"#4daf4a", "#ffe34d", "darkorange"),
as_cmap=True)
dpz.set_cmap(("gas", "metallicity"), cmap)
plotname = dpz.save()
newname = plotname[0].replace(ds.basename, basename)
os.rename(plotname[0], newname)
trident.add_ion_fields(ds, ions=['O VI'])
trident.add_ion_fields(ds, ions=['C II'])
for axis in "y":
### HI
dph = yt.ProjectionPlot(ds,
axis, ('gas', 'H_p0_number_density'),
center=c,
width=(width, "kpc"),
data_source=box)
dph.set_zlim(("gas", "H_p0_number_density"), 1e13, 1e23)
cmap = sns.blend_palette(
("white", "#ababab", "#565656", "black", "#4575b4", "#984ea3",
"#d73027", "darkorange", "#ffe34d"),
as_cmap=True)
dph.set_cmap(("gas", "H_p0_number_density"), cmap)
dph.annotate_scale(size_bar_args={'color': 'black'})
# dph.annotate_marker((25, 25), coord_system='plot')
dph.hide_axes()
# dph.hide_colorbar()
p = dph.plots['H_p0_number_density']
colorbar = p.cb(orientation='horizontal')
dph._setup_plots()
colorbar.set_ticks([1e13, 1e15, 1e17, 1e19, 1e21, 1e23])
colorbar.set_ticklabels(['13', '15', '17', '19', '21', '23'])
colorbar.ax.tick_params(labelsize=20)
plotname = dph.save()
newname = plotname[0].replace(ds.basename, basename)
os.rename(plotname[0], newname)
### CII
dpo = yt.ProjectionPlot(ds,
axis, ('gas', 'C_p1_number_density'),
center=c,
width=(width, "kpc"),
data_source=box)
dpo.set_zlim(("gas", "C_p1_number_density"), 1e5, 1e20)
cmap = sns.blend_palette(
("white", "#ababab", "#565656", "black", "#4575b4", "#984ea3",
"#d73027", "darkorange", "#ffe34d"),
as_cmap=True)
dpo.set_cmap(("gas", "C_p1_number_density"), cmap)
dpo.hide_axes()
plotname = dpo.save()
newname = plotname[0].replace(ds.basename, basename)
os.rename(plotname[0], newname)
### OVI
dpo = yt.ProjectionPlot(ds,
axis, ('gas', 'O_p5_number_density'),
center=c,
width=(width, "kpc"),
data_source=box)
dpo.set_zlim(("gas", "O_p5_number_density"), 1e12, 1e15)
cmap = sns.blend_palette(("white", "black", "#4daf4a", "#4575b4",
"#984ea3", "#d73027", "darkorange"),
as_cmap=True)
dpo.set_cmap(("gas", "O_p5_number_density"), cmap)
dpo.hide_axes()
plotname = dpo.save()
newname = plotname[0].replace(ds.basename, basename)
os.rename(plotname[0], newname)
if False:
dTm = yt.PhasePlot(box, ('gas', 'density'), ('gas', 'temperature'),
['cell_mass'],
weight_field=None,
x_bins=512,
y_bins=512)
dTm.set_cmap("cell_mass", "plasma")
dTm.set_xlim(5e-31, 1e-20)
dTm.set_ylim(100, 3e8)
dTm.set_zlim("cell_mass", 1e32, 5e40)
plotname = dTm.save()
newname = plotname[0].replace(ds.basename, basename)
os.rename(plotname[0], newname)
# =============================================================================
# def velMagnitude(field, data):
# return np.hypot(data['velx'], data['vely'])
# ds.add_field((ds, "velMagnitude"), units="cm/s", function=velMagnitude)
#
# =============================================================================
##################
# Make phase plots
##################
ad = ds.all_data()
# Use tuples to find individual files; otherwise it will pick a default
plot = yt.PhasePlot(ad, ('gas', "density"),
"temperature", ['velocity_magnitude'],
fractional=False,
accumulation=False)
plot.set_unit('velocity_magnitude', 'cm/s') #vely units weird
plot.annotate_title(
"Velocity magnitude probability distribution, yes accumulation")
plot.save("YT_Test_Plots/HDF5/TestC")
selection = ds.CutRegion([0 < ('index', 'x') and ('index', 'x') < 2.3 * kpc])
plot = yt.SlicePlot(selection, 'z', 'density')
plot.save("YT_Test_Plots/HDF5/VectorSelection")
# Streamlines.streamline(ds, dict['velx'], dict['vely'])
# Streamlines.streamlines.integrate_through_volume()
# print("Saving figures...")
# plt.savefig('Plots/VelocityPlot_m2_c1_0076_stream1.png', dpi=1000);
ds = ytf.load_romulusC(output, ions=ion_list)
cen = rom_help.get_romulus_yt_center('romulusC', output, ds)
sp = ds.sphere(cen, (3300, 'kpc'))
#icm = sp.cut_region(["obj[('gas', 'metallicity')] > 0"])
icm = sp.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)"
])
#icm_mask = sp[('gas', 'particle_H_nuclei_density')] > 0.1
#icm = sp.cut_region(["obj[('gas', 'particle_H_nuclei_density')] < 0.1"])
xfield = ('gas', 'spherical_position_radius')
zfield = ('Gas', 'Mass')
yfield = ('gas', 'metal_primordial_cooling_time_ratio')
#icm =
p = yt.PhasePlot(icm, xfield, yfield, zfield, weight_field=None)
p.set_unit(xfield, 'kpc')
p.set_unit(zfield, 'Msun')
p.set_log(xfield, False)
p.set_log(yfield, True)
p.set_ylim(1e-2, 1e2)
p.save('%s_cgm' % (yfield[1]))
yfield = ('gas', 'primordial_cooling_time')
p = yt.PhasePlot(icm, xfield, yfield, zfield, weight_field=None)
p.set_unit(xfield, 'kpc')
p.set_unit(yfield, 'yr')
p.set_unit(zfield, 'Msun')
p.set_log(xfield, False)
p.set_log(yfield, True)
's': 20
})
prj.save(suffix='pdf', mpl_kwargs={"bbox_inches": "tight"})
ad = ds.all_data()
#units = dict(cell_mass='Msun')
#profile = yt.create_profile(ad, ['overdensity','temperature'],\
# n_bins=[128, 128], fields=['cell_mass'],\
# weight_field=None, units=units)
#plot = yt.PhasePlot.from_profile(profile)
#plot.set_zlim('cell_mass',10**5, 10**11)
#plot.annotate_title('%s z = %0.2f'%(title,ds.current_redshift))
#plot.save('r-t-profile%0.2f'%ds.current_redshift,suffix='pdf',mpl_kwargs={"bbox_inches":"tight"})
units = dict(cell_mass='Msun')
#profile = yt.create_profile(ad, ['H_p0_fraction','overdensity'],\
# n_bins=[256, 256], fields=['cell_mass'],\
# weight_field=None, units=units)
#plot = yt.PhasePlot.from_profile(profile)
plot = yt.PhasePlot(ad,
'overdensity',
'H_fraction', ['cell_mass'],
weight_field=None)
plot.set_unit('cell_mass', 'Msun')
plot.set_zlim('cell_mass', 10**3, 10**12)
plot.annotate_title(title + ' z = %0.2f' % ds.current_redshift)
plot.save('h-r-profile%0.2f' % ds.current_redshift,
suffix='pdf',
mpl_kwargs={"bbox_inches": "tight"})
fn_head = fn.split('/')[-1]
ds = GizmoDataset(fn)
c = find_center_iteratively(fn, ds=ds)
trident.add_ion_fields(ds, 'H')
#c = read_amiga_center(amiga_data, fn, ds)
#_, c = ds.find_max('density')
rvir = ds.quan(50, 'kpc')
sp = ds.sphere(c, rvir)
bulk_vel = sp.quantities.bulk_velocity()
#print("Bulk Velocity of Halo = %s" % bulk_vel.to('km/s'))
sp.set_field_parameter("bulk_velocity", bulk_vel)
ad = ds.all_data()
ad.set_field_parameter('center', c)
ad.set_field_parameter('normal', np.array([1, 0, 0]))
ad.set_field_parameter('bulk_velocity', bulk_vel)
p = yt.PhasePlot(ad, ('gas', 'radius'), ('gas', 'radial_velocity'),
('gas', 'H_p0_mass'),
weight_field=('gas', 'ones'))
p.set_unit(('gas', 'radius'), 'kpc')
p.set_unit(('gas', 'radial_velocity'), 'km/s')
p.set_unit(('gas', 'H_p0_mass'), 'Msun')
#p.set_log(('gas', 'radius'), False)
#p.set_log(('gas', 'radial_velocity'), False)
p.set_xlim(1e1, 1e4)
p.set_ylim(-1000, 1000)
p.set_cmap(('gas', 'H_p0_mass'), 'thermal')
#p.set_zlim(('gas', 'H_p0_mass'), 1e12, 1e25)
p.set_xlabel('Radius (kpc)')
p.set_ylabel('Radial Velocity (km/s)')
p.save()
cbar_location="right",
cbar_mode="single",
cbar_size="3%",
cbar_pad="0%",
aspect=False,
)
for i, SnapNum in enumerate([10, 40]):
# Load the data and create a single plot
ds = yt.load("enzo_tiny_cosmology/DD00%2d/DD00%2d" % (SnapNum, SnapNum))
ad = ds.all_data()
p = yt.PhasePlot(
ad,
"density",
"temperature",
[
"cell_mass",
],
weight_field=None,
)
# Ensure the axes and colorbar limits match for all plots
p.set_xlim(1.0e-32, 8.0e-26)
p.set_ylim(1.0e1, 2.0e7)
p.set_zlim(("gas", "cell_mass"), 1e42, 1e46)
# This forces the ProjectionPlot to redraw itself on the AxesGrid axes.
plot = p.plots[("gas", "cell_mass")]
plot.figure = fig
plot.axes = grid[i].axes
if i == 0:
plot.cax = grid.cbar_axes[cnt]
prj._setup_plots()
cnt += 1
del (prj)
plt.rcParams.update({"font.size": 8})
plt.savefig('%s-%s_compare.pdf'%(simtitle[0], simtitle[1]),\
dpi=200, bbox_inches="tight", pad_inches=0.0)
## phase plots done similarly
for i, dset in enumerate(sets):
ds = yt.load(dset)
ds.add_field(('gas', 'log_Density'), function=_logden, units=None)
ds.add_field(('gas', 'log_T'), function=_logT, units=None)
ad = ds.all_data()
plot = yt.PhasePlot(ad, 'density','temperature',['cell_mass'],\
weight_field=None)
profile = yt.create_profile(ad, ['density','temperature'],\
n_bins=[128,128], fields=['cell_mass'],\
weight_field=None, units={'cell_mass':'Msun'})
plot = yt.PhasePlot.from_profile(profile)
plot.set_zlim('cell_mass', 1e5, 1e10)
plot.set_ylim(2e3, 5e6)
plot.set_xlim(3e-30, 1e-24)
plot.set_unit('cell_mass', 'Msun')
plot.set_cmap('cell_mass', "inferno")
print(simtitle[i])
plot.annotate_title('%s' % simtitle[i])
plot.set_font_size(35)
plot.title.set_font_size(55)
if i != 0:
plot.set_xlabel("")
import yt
# Load the dataset.
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
# Create a sphere of radius 100 kpc in the center of the domain.
my_sphere = ds.sphere("c", (100.0, "kpc"))
# Create a PhasePlot object.
# Setting weight to None will calculate a sum.
# Setting weight to a field will calculate an average
# weighted by that field.
plot = yt.PhasePlot(my_sphere,
"density",
"temperature",
"cell_mass",
weight_field=None)
# Set the units of mass to be in solar masses (not the default in cgs)
plot.set_unit('cell_mass', 'Msun')
# Save the image.
# Optionally, give a string as an argument
# to name files with a keyword.
plot.save()
import yt
# Load the dataset.
ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030")
# Create a sphere of radius 100 kpc in the center of the domain.
my_sphere = ds.sphere("c", (100.0, "kpc"))
# Create a PhasePlot object.
# Setting weight to None will calculate a sum.
# Setting weight to a field will calculate an average
# weighted by that field.
plot = yt.PhasePlot(
my_sphere,
("gas", "density"),
("gas", "temperature"),
("gas", "mass"),
weight_field=None,
)
# Set the units of mass to be in solar masses (not the default in cgs)
plot.set_unit(("gas", "mass"), "Msun")
# Save the image.
# Optionally, give a string as an argument
# to name files with a keyword.
plot.save()
