def test_particle_profile_negative_field():
# see Issue #1340
n_particles = int(1e4)
ppx, ppy, ppz = np.random.normal(size=[3, n_particles])
pvx, pvy, pvz = -np.ones((3, n_particles))
data = {
'particle_position_x': ppx,
'particle_position_y': ppy,
'particle_position_z': ppz,
'particle_velocity_x': pvx,
'particle_velocity_y': pvy,
'particle_velocity_z': pvz
}
bbox = 1.1 * np.array([[min(ppx), max(ppx)], [min(ppy), max(ppy)],
[min(ppz), max(ppz)]])
ds = yt.load_particles(data, bbox=bbox)
ad = ds.all_data()
profile = yt.create_profile(ad,
["particle_position_x", "particle_position_y"],
"particle_velocity_x",
weight_field=None)
assert profile['particle_velocity_x'].min() < 0
def to_yt_dataset(self, box_size, ptypes=None):
"""
Create an in-memory yt dataset for the particles.
Parameters
----------
box_size : float
The width of the domain on a side, in kpc.
ptypes : string or list of strings, optional
The particle types to export to the dataset. If
not set, all will be exported.
"""
from yt import load_particles
data = self.fields.copy()
if ptypes is None:
ptypes = self.particle_types
ptypes = ensure_list(ptypes)
for ptype in ptypes:
pos = data.pop((ptype, "particle_position"))
vel = data.pop((ptype, "particle_velocity"))
for i, ax in enumerate("xyz"):
data[ptype, "particle_position_%s" % ax] = pos[:,i]
data[ptype, "particle_velocity_%s" % ax] = vel[:,i]
return load_particles(data, length_unit="kpc", bbox=[[0.0, box_size]]*3,
mass_unit="Msun", time_unit="Myr")
def plot(data, bbox):
"""
This function ...
:param data:
:param bbox:
:return:
"""
#yt.load_amr_grids()
ds = yt.load_particles(data, length_unit=parsec, mass_unit=1e8*Msun, n_ref=256, bbox=bbox)
#xwidth = (data.x_span,"pc",)
#ywidth = (data.y_span,"pc",)
xwidth = (bbox[0][1]-bbox[0][0], "pc",)
ywidth = (bbox[1][1]-bbox[1][0], "pc",)
#print(ds.derived_field_list)
what = ('deposit', 'io_density')
slc = yt.SlicePlot(ds, "z", what)
slc.set_width((xwidth,ywidth,))
#slc.show() # only for ipython notebook? :(
slc.save("test.pdf")
def create_sph_fields(data_source: YTSelectionContainer,
ptype: str = "all",
*args,
**kwargs) -> Dataset:
"""
Return a dataset with sph interpolation
Parameters:
-----------
data_source : YTSelectionContainer
The data source from which particles will be extracted
ptype : str
The type of particle to extract
args, kwargs : extra arguments will be passed to `add_sph_fields`
Returns
-------
ds : Dataset
A dataset with sph interpolation.
"""
ds = data_source.ds
if hasattr(ds, "add_sph_fields"):
ds.add_sph_fields(*args, **kwargs)
return ds
logger.debug("Loading data from data source")
data = {(ptype, fname): data_source[ftype, fname]
for (ftype, fname) in ds.field_list
if (ftype == ptype) and (data_source[ftype, fname].ndim == 1)}
# Make sure position and masses are copied
for k in "xyz":
data[ptype,
f"particle_position_{k}"] = data_source[ptype,
f"particle_position_{k}"]
data[ptype, "particle_mass"] = data_source[ptype, "particle_mass"]
data[ptype, "particle_identity"] = data_source[ptype, "particle_identity"]
data[ptype, "particle_family"] = data_source[ptype, "particle_family"]
periodicity = (True, True, True)
# No support for aperiodicity for now
# L, R = data_source.get_bbox()
# periodicity = (
# np.asarray(ds.periodicity)
# & (ds.domain_left_edge == L)
# & (ds.domain_right_edge == R)
# )
logger.debug("Create particle dataset")
sph_ds = yt.load_particles(data,
data_source=data_source,
periodicity=periodicity)
sph_ds.current_redshift = ds.current_redshift # Copy current redshift
sph_ds.add_sph_fields(*args, **kwargs, sph_ptype=ptype)
return sph_ds
def plot_particle_density(self, projection_plane, savename):
"""
Inputs:
------
projection_plane: int or str
0,1,2 or 'x', 'y', 'z' to set which cross section of the 3D data is plotts
savename: str
String to save file name. Leave off the file extension
Output:
------
A 2D particle plot showing the mass density of the cut box
"""
bbox = 1.1 * np.array([[np.min(self.x), np.max(self.x)],
[np.min(self.y), np.max(self.y)],
[np.min(self.z), np.max(self.z)]])
ds = yt.load_particles(self.data,
length_unit=kpc,
mass_unit=1e10,
bbox=bbox,
n_ref=4)
center = self.com
p = yt.ParticleProjectionPlot(
ds, projection_plane,
['particle_mass'
]) #, center=center)#, width=self.box_size, depth=self.box_size)
p.set_colorbar_label('particle_mass', 'Msun')
#p.zoom(2)
p.annotate_text((0.7, 0.85),
'%s Gyr' % round(self.header_time(), 2),
coord_system='figure',
text_args={'color': 'black'})
p.save('%s' % savename)
return
def yt4x_projection(self, cut_positions, cut_weights, width,
axis=0, method='mip', pixels=2048, img_rotate=0,
length_unit='kpc', mass_unit='Msun', **kwargs):
"""
use the yt-4 method of creating a ProjectionPlot out of
particle data defined cut_positions and cut_weights,
Args:
* cut_positions (N x 3 array): array of particle positions
* cut_weights (len N array): array of particle weights
* width (float): size of box to visualize, in length_unit
* axis (int or str): axis to project along
* method (str): method to pass to ProjectionPlot. most
likely either 'integrate' for LOS densities
or 'mip' for max-in-pixel volume densities
* pixels (int): number of pixels in the image
(scales the dpi; uses a fixed image size)
* img_rotate (int): either 0, 90, 180, or 270 to rotate the image
(in the plane) through that many degrees.
* length_unit (str): unit of the cut_positions
* mass_unit (str): unit of the cut_weights
* ptype (str): particle type being visualized. only matters for the colorbar.
** kwargs: passed to yt.ProjectionPlot
Returns:
a yt.ProjectionPlot instance
"""
self.method = method
## prepare a dictionary with our data
## here the data does HAVE to be in 'io', as that's where
## the sph field adder looks
data = self.prepare_data_dictionary(cut_positions, cut_weights, 'io', axis, img_rotate)
## get the bounding box for our particles
bbox = self.get_bbox(width)
## load the particles into yt. no n_ref this time because we're not
## putting the particles onto a grid (so no refining)
ds = yt.load_particles(data, length_unit=length_unit, mass_unit=mass_unit, bbox=bbox,
periodicity=(False, False, False))
## since we're not putting on a grid, we have to calculate
## densities in an sph-like way. this method adds the
## smoothing length and density fields
ds.add_sph_fields()
self.field = ('io', 'density')
self.field_name = self.field[1]
## now make the projection.
self.proj = yt.ProjectionPlot(ds, axis, self.field, center=np.zeros(3),
width=(width, length_unit), buff_size=(pixels, pixels), method=self.method)
## again, fix up the background color etc.
self.set_bgcolor_and_units()
## and set our figure size again. no need to set our
## buff size afterwards because we can set it in the
## constructor now
self.proj.set_figure_size(self.figure_size)
self.dpi = pixels / self.figure_size
return self.proj
def yt3x_projection(self, cut_positions, cut_weights, width,
n_ref=8, axis=0, method='mip', pixels=2048, img_rotate=0,
length_unit='kpc', mass_unit='Msun', interpolation='bicubic',
**kwargs):
"""
use the yt-3 method of creating a ProjectionPlot out of
particle data defined cut_positions and cut_weights,
Args:
* cut_positions (N x 3 array): array of particle positions
* cut_weights (len N array): array of particle weights
* width (float): size of box to visualize, in length_unit
* n_ref (int): number of particles to allow in a cell before
refining (i.e. refines cells with > n_ref particles).
smaller values give a higher resolution image
* axis (int or str): axis to project along
* method (str): method to pass to ProjectionPlot. most
likely either 'integrate' for LOS densities
or 'mip' for max-in-pixel volume densities
* pixels (int): number of pixels in the image
(scales the dpi; uses a fixed image size)
* img_rotate (int): either 0, 90, 180, or 270 to rotate the image
(in the plane) through that many degrees.
* length_unit (str): unit of the cut_positions
* mass_unit (str): unit of the cut_weights
* interpolation (str): type of interpolation to apply to the image
** kwargs: passed to yt.ProjectionPlot
Returns:
a yt.ProjectionPlot instance
"""
## set the method as a class variable for future function to use
self.method = method
## put the data in the structure we want
## note that we'll use 'io' here as the species name, but
## it's really irrelevant in yt3 -- we can use whatever we want
## as long as we're consistent below
data = self.prepare_data_dictionary(cut_positions, cut_weights, 'io', axis, img_rotate)
## build the bounding box
bbox = self.get_bbox(width)
## load the particles into yt. no periodicity because we've artificially trimmed the particles
ds = yt.load_particles(data, length_unit=length_unit, mass_unit=mass_unit, bbox=bbox,
n_ref=n_ref, periodicity=(False, False, False))
self.field = ('deposit', 'io_density')
self.field_name = self.field[1]
## make the actual projection
self.proj = yt.ProjectionPlot(ds, axis, self.field, method=self.method,
center=np.zeros(3), width=(width, length_unit), **kwargs)
## set the interpolation between pixels in the image
plot = self.proj.plots[list(self.proj.plots)[0]]
ax = plot.axes
img = ax.images[0]
img.set_interpolation(interpolation)
## set the buffer size -- have to do this in post in yt3 main branch
self.proj.set_buff_size((pixels, pixels))
## set the figure size too
self.proj.set_figure_size(self.figure_size)
## store the appropriate DPI for later saving
self.dpi = pixels / self.figure_size
## fig the color of the background and set units of the colorbar
self.set_bgcolor_and_units()
return self.proj
pos -= CM
ppx, ppy, ppz = pos.T
# Creates data to work with in YT
data = {
'particle_position_x': pos[:, 0],
'particle_position_y': pos[:, 1],
'particle_position_z': pos[:, 2],
'particle_mass': sn.MassTable[1] * np.ones(len(pos))
}
bbox = 1.1 * np.array([[min(ppx), max(ppx)], [min(ppy), max(ppy)],
[min(ppz), max(ppz)]])
ds = yt.load_particles(data,
length_unit=1000 * parsec,
mass_unit=1e10 * Msun,
n_ref=64,
bbox=bbox)
ad = ds.all_data()
# This is generated with "cloud-in-cell" interpolation.
cic_density = "deposit", "all_cic"
# Neares Neighbor
nn_density = "deposit", "all_density"
nn_deposited_mass = "deposit", "all_mass"
particle_count_per_cell = "deposit", "all_count"
# Choose a center for the render.
c = [0, 0, 0]
'''
# Create the off axis projection.
def plotHalo(filename, pos, lvl, halo, redshift):
# Font size
MEDIUM_SIZE = 20
SMALL_SIZE = 20
SSSMALL_SIZE = 11
plt.rc('font', size=SSSMALL_SIZE) # controls default text sizes
plt.rc('axes', titlesize=MEDIUM_SIZE) # fontsize of the axes title
plt.rc('axes', labelsize=MEDIUM_SIZE) # fontsize of the x and y labels
plt.rc('xtick', labelsize=SMALL_SIZE) # fontsize of the tick labels
plt.rc('ytick', labelsize=SMALL_SIZE) # fontsize of the tick labels
#rad = (a*b*c)**(1./3.)
# Filter box
#ind = np.where((abs(pos[:,0])< 1.5*a) & (abs(pos[:,1])< 1.5*a)& (abs(pos[:,2])< 2*a))[0]
npos = pos[:, :]
ppx, ppy, ppz = npos.T
# Creates data to work with in YT
data = {
'particle_position_x': ppx,
'particle_position_y': ppy,
'particle_position_z': ppz,
'particle_mass': DMass * np.ones(len(npos))
}
bbox = 1.1 * np.array([[min(ppx), max(ppx)], [min(ppy), max(ppy)],
[min(ppz), max(ppz)]])
ds = yt.load_particles(data,
length_unit=1000 * parsec,
mass_unit=1e10 * Msun,
n_ref=64,
bbox=bbox)
ad = ds.all_data()
# This is generated with "cloud-in-cell" interpolation.
#cic_density = "deposit", "all_cic"
# Neares Neighbor
nn_density = "deposit", "all_density"
#nn_deposited_mass = "deposit", "all_mass"
#particle_count_per_cell = "deposit", "all_count"
# Choose a center for the render.
c = [0, 0, 0]
p = yt.ProjectionPlot(ds,
'z',
nn_density,
center=c,
weight_field=nn_density,
width=(0.2 * (npos.max() - npos.min()), 'kpc'))
#p = yt.ParticlePlot(ds, 'particle_position_x','particle_position_y', weight_field=nn_density, width=(2*rad,2*rad))
# Title
p.annotate_title(filename.split('.')[0])
# Changes CMap
p.set_cmap(nn_density, 'inferno')
# Draws density contour
p.annotate_contour(nn_density, ncont=10, take_log=True)
# Plots center of the halo (potential)
p.annotate_marker(
(0, 0),
coord_system='plot',
plot_args={
'color': 'blue',
's': 500,
'label': "z=" + '{:.2e}'.format(float(redshift))
})
p.set_figure_size(6)
#p.save("tmp.png")
#p.display()
##############################################################################################
# Gets matplotlib figure,axes
mpl = p.plots[nn_density]
#mpl.axes.plot([0],[0], marker = 'o', label = "z="+'{:.2e}'.format(float(redshift)))
# Draws ellipse
from matplotlib.patches import Ellipse
elli = Ellipse(xy=[0, 0],
width=2 * 0,
height=2 * 0,
fill=False,
linewidth=0)
# Filter box
mpl.axes.add_artist(elli)
leg = mpl.axes.legend(facecolor='w', loc=0)
#text = leg.get_texts()
#plt.setp(text, color = 'w')
#mpl.figure.savefig("Otro.png")
#############################################################################################
mpl.figure.savefig("../Plots/" + lvl + "/" + halo + "/" + filename)
plt.close()
[pz1.min(), pz1.max()]])
px2 = np.random.normal(size=128**3, loc=10.0)
py2 = np.random.normal(size=128**3, loc=10.0)
pz2 = np.random.normal(size=128**3, loc=10.0)
bbox2 = np.array([[px2.min(), px2.max()], [py2.min(), py2.max()],
[pz2.min(), pz2.max()]])
print(bbox1, bbox2)
ds1 = yt.load_particles(
{
'particle_position_x': px1,
'particle_position_y': py1,
'particle_position_z': pz1,
'particle_mass': np.ones(128**3)
},
1.0,
bbox=bbox1)
ds2 = yt.load_particles(
{
'particle_position_x': px2,
'particle_position_y': py2,
'particle_position_z': pz2,
'particle_mass': np.ones(128**3)
},
1.0,
bbox=bbox2)
def load_brick(filename, bbox=None, center=None, return_ds=True):
"""Load a brick file as outputed by HaloFinder.
You can pass a bbox (in Mpc) to force the box size."""
with open(filename, "rb") as f:
# Load headers
hvals = {}
attrs = (('nbodies', 1, 'i'),
('particle_mass', 1, 'f'),
('aexp', 1, 'f'),
('omega_t', 1, 'f'),
('age_univ', 1, 'f'),
(('nhalos', 'nsubhalos'), 2, 'i'))
hvals.update(fpu.read_attrs(f, attrs))
# Load halo data
halos = {}
for _ in range(hvals['nhalos']):
tmp = _read_halo(f)
halo_id = tmp.get('particle_identifier')
halos[halo_id] = tmp
for _ in range(hvals['nsubhalos']):
tmp = _read_halo(f)
halo_id = tmp.get('particle_identifier')
halos[halo_id] = tmp
if not return_ds:
return halos
# Now converts everything into yt-aware quantities
def g(key):
return [halos[i][key] for i in halos]
am_unit = (1, 'Msun*Mpc*km/s')
unit_dict = {
'particle_identifier': (1, '1'), 'particle_mass': (1e11, 'Msun'),
'particle_position_x': (1, 'Mpc'), 'particle_position_y': (1, 'Mpc'),
'particle_position_z': (1, 'Mpc'), 'particle_velocity_x': (1, 'km/s'),
'particle_velocity_y': (1, 'km/s'), 'particle_velocity_z': (1, 'km/s'),
'subhalo_level': (1, '1'), 'subhalo_hosthalo': (1, '1'),
'subhalo_host': (1, '1'),
'subhalo_number': (1, '1'), 'subhalo_next': (1, '1'),
'particle_angular_momentum_x': am_unit,
'particle_angular_momentum_y': am_unit,
'particle_angular_momentum_z': am_unit,
'virial_radius': (1, 'Mpc'), 'virial_mass': (1e11, 'Msun'),
'virial_temp': (1, 'K'),
'virial_vel': (1, 'km/s'),
'particle_spin': (1, '1'), 'particle_radius': (1, 'Mpc'),
'particle_axis_a': (1, 'Mpc'), 'particle_axis_b': (1, 'Mpc'),
'particle_axis_c': (1, 'Mpc')}
data = {}
for key in unit_dict:
intensity = unit_dict[key][0]
unit = unit_dict[key][1]
arr = np.array([halos[i][key] for i in halos]) * intensity
data[key] = (arr, unit)
n_ref = 1
ppx, ppy, ppz = [data['particle_position_%s' % d][0]
for d in ('x', 'y', 'z')]
if bbox is not None:
try:
bbox = np.array(bbox.to('Mpc'))
except:
bbox = np.array(bbox)
width = bbox[1] - bbox[0]
left = -width / 2
right = +width / 2
else:
left = np.array([min(ppx), min(ppy), min(ppz)])
right = np.array([max(ppx), max(ppy), max(ppz)])
data['particle_position_x'] = (ppx - left[0]), 'Mpc'
data['particle_position_y'] = (ppy - left[1]), 'Mpc'
data['particle_position_z'] = (ppz - left[2]), 'Mpc'
right -= left
left -= left
bbox = np.array([left, right]).T
ds = yt.load_particles(data, length_unit=U.Mpc, mass_unit=1e11*U.Msun,
bbox=bbox, n_ref=n_ref)
@yt.particle_filter('halos', requires=["particle_mass"],
filtered_type='all')
def is_halo(pfilter, data):
return data[(pfilter.filtered_type, "particle_mass")] > 0
ds.add_particle_filter('halos')
return ds
#load the particles into memory
ppx = f[basePath+particlesPath+"/electrons/position/x"][:]
ppy = f[basePath+particlesPath+"/electrons/position/y"][:]
ppz = f[basePath+particlesPath+"/electrons/position/z"][:]
pmx = f[basePath+particlesPath+"/electrons/momentum/x"][:]
pmy = f[basePath+particlesPath+"/electrons/momentum/y"][:]
pmz = f[basePath+particlesPath+"/electrons/momentum/z"][:]
ppm = np.ones_like(ppx) # Generate the same mass for all particles
#create a dictionary for yt
#! you can only use fieldtypes already known by yt
data = {'particle_position_x': ppx, # assumes input is cm
'particle_position_y': ppy,
'particle_position_z': ppz,
'particle_momentum_x': pmx, # assumes input is cm/s
'particle_momentum_y': pmy,
'particle_momentum_z': pmz,
'particle_mass': ppm}
#create the size of the simulation box
bbox = np.array([[min(ppx), max(ppx)], [min(ppy), max(ppy)], [min(ppz), max(ppz)]])
print bbox
#load the particles into yt
ds = yt.load_particles(data, n_ref=64, bbox=bbox)
#plot the particles
p = yt.ProjectionPlot(ds, "y", ["all_density"])
p.show()
ppy = f[basePath + particlesPath + "/electrons/position/y"][:]
ppz = f[basePath + particlesPath + "/electrons/position/z"][:]
pmx = f[basePath + particlesPath + "/electrons/momentum/x"][:]
pmy = f[basePath + particlesPath + "/electrons/momentum/y"][:]
pmz = f[basePath + particlesPath + "/electrons/momentum/z"][:]
ppm = np.ones_like(ppx) # Generate the same mass for all particles
#create a dictionary for yt
#! you can only use fieldtypes already known by yt
data = {
'particle_position_x': ppx, # assumes input is cm
'particle_position_y': ppy,
'particle_position_z': ppz,
'particle_momentum_x': pmx, # assumes input is cm/s
'particle_momentum_y': pmy,
'particle_momentum_z': pmz,
'particle_mass': ppm
}
#create the size of the simulation box
bbox = np.array([[min(ppx), max(ppx)], [min(ppy), max(ppy)],
[min(ppz), max(ppz)]])
print bbox
#load the particles into yt
ds = yt.load_particles(data, n_ref=64, bbox=bbox)
#plot the particles
p = yt.ProjectionPlot(ds, "y", ["all_density"])
p.show()
def dummy_datasets(dataset, field):
normal = dataset.get_field_parameter("normal")
min_pos_x = abs(
dataset[field,
'particle_position_relative_x'].in_units("cm").value.min())
min_pos_y = abs(
dataset[field,
'particle_position_relative_y'].in_units("cm").value.min())
min_pos_z = abs(
dataset[field,
'particle_position_relative_z'].in_units("cm").value.min())
sim_data_verb = {
"particle_mass":
dataset.ds.arr(dataset[field, "particle_mass"].in_units("g").value,
"g"),
"particle_age_flip":
dataset.ds.arr(dataset[field, 'particle_age_flip'].in_units("s").value,
"s"),
"particle_position_x":
dataset.ds.arr(
dataset[field, 'particle_position_relative_x'].in_units("cm").value
+ min_pos_x, "cm"),
"particle_position_y":
dataset.ds.arr(
dataset[field, 'particle_position_relative_y'].in_units("cm").value
+ min_pos_y, "cm"),
"particle_position_z":
dataset.ds.arr(
dataset[field, 'particle_position_relative_z'].in_units("cm").value
+ min_pos_z, "cm"),
"particle_velocity_x":
dataset.ds.arr(
dataset[field,
'particle_velocity_relative_x'].in_units("cm/s").value,
"cm/s"),
"particle_velocity_y":
dataset.ds.arr(
dataset[field,
'particle_velocity_relative_x'].in_units("cm/s").value,
"cm/s"),
"particle_velocity_z":
dataset.ds.arr(
dataset[field,
'particle_velocity_relative_x'].in_units("cm/s").value,
"cm/s"),
}
box_min = np.hstack((sim_data_verb["particle_position_x"].v,
sim_data_verb["particle_position_y"].v,
sim_data_verb["particle_position_z"].v)).min()
box_max = np.hstack((sim_data_verb["particle_position_x"].v,
sim_data_verb["particle_position_y"].v,
sim_data_verb["particle_position_z"].v)).max()
bbox = 1.0 * np.array([[box_min, box_max], [box_min, box_max],
[box_min, box_max]])
ds = yt.load_particles(sim_data_verb,
length_unit="cm",
mass_unit="g",
time_unit="s",
bbox=bbox,
n_ref=1)
ad = ds.all_data()
new_center = ad.ds.arr([min_pos_x, min_pos_y, min_pos_z], "cm")
return ds, new_center
bbox = np.array([[min(data['particle_position_x']), max(data['particle_position_x'])],
[min(data['particle_position_y']), max(data['particle_position_y'])],
[min(data['particle_position_z']), max(data['particle_position_z'])]])
loading_params = {'length_unit':kiloparsec.in_cgs(),
'mass_unit':gram.in_cgs(),
'time_unit':second.in_cgs(),
'velocity_unit':(centimeter/second).in_cgs(),
}
for ii in (1,10,100):
d = {x: data[x][::ii] for x in data}
ds = yt.load_particles(d,
periodicity=(False,False,False),
bbox=bbox,
**loading_params)
direction = 'z'
proj = yt.ProjectionPlot(ds, direction, ('deposit','all_density'),)
proj.set_zlim('all', 1e-10, 1e-1)
proj.set_cmap('all','cubehelix')
proj.save("z_projection_every{0}th.png".format(ii))
for ii in range(4):
d = {x: data[x][ii*(len(data[x])/4):(ii+1)*(len(data[x])/4)] for x in data}
ds = yt.load_particles(d,
periodicity=(False,False,False),
bbox=bbox,
**loading_params)
def test_particle_profile_negative_field():
# see Issue #1340
n_particles = int(1e4)
ppx, ppy, ppz = np.random.normal(size=[3, n_particles])
pvx, pvy, pvz = -np.ones((3, n_particles))
data = {
'particle_position_x': ppx,
'particle_position_y': ppy,
'particle_position_z': ppz,
'particle_velocity_x': pvx,
'particle_velocity_y': pvy,
'particle_velocity_z': pvz
}
bbox = 1.1 * np.array([[min(ppx), max(ppx)], [min(ppy), max(ppy)],
[min(ppz), max(ppz)]])
ds = yt.load_particles(data, bbox=bbox)
ad = ds.all_data()
profile = yt.create_profile(ad,
["particle_position_x", "particle_position_y"],
"particle_velocity_x",
logs={
'particle_position_x': True,
'particle_position_y': True,
'particle_position_z': True
},
weight_field=None)
assert profile['particle_velocity_x'].min() < 0
assert profile.x_bins.min() > 0
assert profile.y_bins.min() > 0
profile = yt.create_profile(ad,
["particle_position_x", "particle_position_y"],
"particle_velocity_x",
weight_field=None)
assert profile['particle_velocity_x'].min() < 0
assert profile.x_bins.min() < 0
assert profile.y_bins.min() < 0
# can't use CIC deposition with log-scaled bin fields
with assert_raises(RuntimeError):
yt.create_profile(ad, ["particle_position_x", "particle_position_y"],
"particle_velocity_x",
logs={
'particle_position_x': True,
'particle_position_y': False,
'particle_position_z': False
},
weight_field=None,
deposition='cic')
# can't use CIC deposition with accumulation or fractional
with assert_raises(RuntimeError):
yt.create_profile(ad, ["particle_position_x", "particle_position_y"],
"particle_velocity_x",
logs={
'particle_position_x': False,
'particle_position_y': False,
'particle_position_z': False
},
weight_field=None,
deposition='cic',
accumulation=True,
fractional=True)
m = data[0]
x = data[1]
y = data[2]
z = data[3]
data_dic = { 'particle_mass' : m,
'particle_position_x': x,
'particle_position_y': y,
'particle_position_z': z }
bbox_width = [ max(x)-min(x), max(y)-min(y), max(z)-min(z) ]
bbox = np.array( [ [ min(x)-bext*bbox_width[0], max(x)+bext*bbox_width[0] ],
[ min(y)-bext*bbox_width[1], max(y)+bext*bbox_width[1] ],
[ min(z)-bext*bbox_width[2], max(z)+bext*bbox_width[2] ] ] )
ds = yt.load_particles( data_dic, length_unit=unit_l, mass_unit=unit_m, time_unit=unit_t,
n_ref=nref, bbox=bbox, sim_time=time, periodicity=(False,False,False) )
# plot
p = yt.ParticleProjectionPlot( ds, proj_axis, fields=field, center=plot_center,
width=(plot_width[0],plot_width[1]), depth=plot_width[2] )
# p = yt.ParticlePlot( ds, 'particle_position_x', 'particle_position_y', 'particle_mass' )
p.set_unit( field, 'Msun' )
p.set_unit( 'particle_position_x', 'Mpc' )
p.set_unit( 'particle_position_y', 'Mpc' )
p.set_zlim( field, 1.0e0, 6.0e0 )
p.set_cmap( field, colormap )
p.annotate_timestamp( time_unit='Myr', corner='upper_right', text_args={'color':'k'} )
p.save( prefix_out+'_%06d'%idx+'.png', mpl_kwargs={'dpi':dpi} )
