def __call__(self, plot):
data = plot.data
if iterable(self.width):
validate_width_tuple(self.width)
self.width = plot.data.ds.quan(self.width[0], self.width[1])
elif isinstance(self.width, YTQuantity):
self.width = plot.data.ds.quan(self.width.value, self.width.units)
else:
self.width = plot.data.ds.quan(self.width, "code_length")
# we construct a rectangular prism
x0 = plot.xlim[0].to("code_length")
x1 = plot.xlim[1].to("code_length")
y0 = plot.ylim[0].to("code_length")
y1 = plot.ylim[1].to("code_length")
xx0, xx1 = plot._axes.get_xlim()
yy0, yy1 = plot._axes.get_ylim()
if type(self.data_source)==YTCutRegion:
mylog.warn("Parameter 'width' is ignored in annotate_particles if the "
"data_source is a cut_region. "
"See https://github.com/yt-project/yt/issues/1933 for further details.")
self.region=self.data_source
else:
self.region=self._get_region((x0,x1), (y0,y1), plot.data.axis, data)
ax = data.axis
xax = plot.data.ds.coordinates.x_axis[ax]
yax = plot.data.ds.coordinates.y_axis[ax]
axis_names = plot.data.ds.coordinates.axis_name
field_x = "particle_position_%s" % axis_names[xax]
field_y = "particle_position_%s" % axis_names[yax]
pt = self.ptype
self.periodic_x = plot.data.ds.periodicity[xax]
self.periodic_y = plot.data.ds.periodicity[yax]
self.LE = plot.data.ds.domain_left_edge[xax], \
plot.data.ds.domain_left_edge[yax]
self.RE = plot.data.ds.domain_right_edge[xax], \
plot.data.ds.domain_right_edge[yax]
period_x = plot.data.ds.domain_width[xax]
period_y = plot.data.ds.domain_width[yax]
particle_x, particle_y = self._enforce_periodic(self.region[pt, field_x],
self.region[pt, field_y],
x0, x1, period_x,
y0, y1, period_y)
gg = ( ( particle_x >= x0 ) & ( particle_x <= x1 )
& ( particle_y >= y0 ) & ( particle_y <= y1 ) )
if self.indices is not None:
mask_to_get = na.zeros(self.indices.shape, dtype='int32')
found_any, mask = particle_ops.mask_particles(
self.indices.astype('int64'), self.region['particle_index'].astype('int64'), mask_to_get)
gg = ( gg & (mask == 1) )
print( "nparticles in particle callback.", mask_to_get.sum())
if self.minimum_mass is not None:
gg &= (self.region[pt, "particle_mass"] >= self.minimum_mass)
if gg.sum() == 0: return
px, py = [particle_x[gg][::self.stride], particle_y[gg][::self.stride]]
px, py = self._convert_to_plot(plot, [px, py])
plot._axes.scatter(px, py, edgecolors='None', marker=self.marker,
s=self.p_size, c=self.color,alpha=self.alpha)
plot._axes.set_xlim(xx0,xx1)
plot._axes.set_ylim(yy0,yy1)
def deposit_target_particles(field, data):
#pdb.set_trace()
target_indices = data.get_field_parameter('target_indices')
blank = np.zeros(data.ActiveDimensions, dtype='float64')
if not hasattr(target_indices, 'sum'):
return blank
if data.NumberOfParticles == 0: return blank
if dbg > 0:
if hasattr(target_indices, 'sum'):
print("indices inside", target_indices.sum())
else:
print("indices inside", target_indices)
return blank
#int 32 because it's just a flag.
#mask_to_get = np.zeros(target_indices.shape, dtype='int32')
mask_to_get = data.get_field_parameter('mask_to_get')
my_indices = data['particle_index'].astype('int64')
found_any, mask = particle_ops.mask_particles(target_indices,
my_indices, mask_to_get)
data.set_field_parameter('mask_to_get',
mask_to_get) #keeping the mask is faster
pos_to_get = data['particle_position'][mask == 1]
d = data.deposit(pos_to_get, method="count")
d = data.ds.arr(d, input_units="cm**-3")
#print("ahoy.", d.sum())
return data.apply_units(d, field.units)
def __call__(self, plot):
data = plot.data
if iterable(self.width):
self.width = np.float64(
plot.data.ds.quan(self.width[0], self.width[1]))
# we construct a recantangular prism
x0, x1 = plot.xlim
y0, y1 = plot.ylim
xx0, xx1 = plot._axes.get_xlim()
yy0, yy1 = plot._axes.get_ylim()
if self.bool is None:
reg = self._get_region((x0, x1), (y0, y1), plot.data.axis, data)
else:
reg = self.bool
ax = data.axis
xax = plot.data.ds.coordinates.x_axis[ax]
yax = plot.data.ds.coordinates.y_axis[ax]
axis_names = plot.data.ds.coordinates.axis_name
field_x = "particle_position_%s" % axis_names[xax]
field_y = "particle_position_%s" % axis_names[yax]
pt = self.ptype
gg = ((reg[pt, field_x] >= x0) & (reg[pt, field_x] <= x1)
& (reg[pt, field_y] >= y0) & (reg[pt, field_y] <= y1))
if self.indices != None:
print "particle callback warning: this might get expensive"
mask_to_get = na.zeros(self.indices.shape, dtype='int32')
found_any, mask = particle_ops.mask_particles(
self.indices.astype('int64'),
reg['particle_index'].astype('int64'), mask_to_get)
gg = (gg & (mask == 1))
print "nparticles do it.", mask_to_get.sum()
if False:
if self.ptype is not None:
gg &= (reg["particle_type"] == self.ptype)
if gg.sum() == 0: return
if self.stars_only:
gg &= (reg["creation_time"] > 0.0)
if gg.sum() == 0: return
if self.dm_only:
gg &= (reg["creation_time"] <= 0.0)
if gg.sum() == 0: return
if self.minimum_mass is not None:
gg &= (reg["ParticleMassMsun"] >= self.minimum_mass)
if gg.sum() == 0: return
plot._axes.hold(True)
px, py = self.convert_to_plot(plot, [
np.array(reg[pt, field_x][gg][::self.stride]),
np.array(reg[pt, field_y][gg][::self.stride])
])
plot._axes.scatter(px,
py,
edgecolors='None',
marker=self.marker,
s=self.p_size,
c=self.color)
plot._axes.set_xlim(xx0, xx1)
plot._axes.set_ylim(yy0, yy1)
plot._axes.hold(False)
def deposit_target_particles_1(field, data):
#pdb.set_trace()
indices_late = data.get_field_parameter('indices_late')
blank = np.zeros(data.ActiveDimensions, dtype='float64')
if not hasattr(indices_late,'sum'):
return blank
if data.NumberOfParticles == 0: return blank
if dbg > 0:
if hasattr(indices_late,'sum'):
print( "indices inside", indices_late.sum())
else:
print( "indices inside", indices_late)
return blank
#int 32 because it's just a flag.
#mask_to_get = np.zeros(indices_late.shape, dtype='int32')
mask_to_get = data.get_field_parameter('mask_to_get')
t0 = data.get_field_parameter('timer')
my_indices = data['particle_index'].astype('int64')
#print " min thing"
#mask_to_get[ indices_late < my_indices.min()] = 1
#mask_to_get[ indices_late > my_indices.max()] = 1
#print " left", mask_to_get.size - mask_to_get.sum()
#print " search"
found_any, mask = particle_ops.mask_particles(
indices_late, my_indices, mask_to_get)
data.set_field_parameter('mask_to_get',mask_to_get)
pos_to_get = data['particle_position'][mask == 1]
d = data.deposit(pos_to_get, method = "count")
d = data.ds.arr(d, input_units = "cm**-3")
t1 = time.time()
#print " DT", t1-t0[-1]
data.set_field_parameter('timer',t0+[t1])
return data.apply_units(d, field.units)
def centroid_line(dirname, target_frame, source_indices, prefix=None, extra_cuts=None, alpha = 0.0):
"""line at angle Alpha wrt y axis through center"""
"""hard coded size. Fix that"""
field = 'density'
ds = yt.load('%s/DD%04d/data%04d'%(dirname,target_frame,target_frame))
reg = ds.all_data()
#source_indices = source_region['particle_index']
mask_to_get = na.zeros(source_indices.shape, dtype='int32')
found_any, mask = particle_ops.mask_particles(
source_indices.astype('int64'), reg['particle_index'].astype('int64'), mask_to_get)
part_x = reg['particle_position_x'][mask==1]
part_y = reg['particle_position_y'][mask==1]
part_z = reg['particle_position_z'][mask==1]
index = reg['particle_index'][mask==1]
if extra_cuts is not None:
if extra_cuts == 80:
""" how to pass in this complex logic?"""
keep_low_x = part_x < 0.5
print "shape", part_x.shape, keep_low_x.sum()
part_x = part_x[ keep_low_x]
part_y = part_y[ keep_low_x]
part_z = part_z[ keep_low_x]
index = index[keep_low_x]
cen_x = part_x.sum()/part_x.shape
cen_y = part_y.sum()/part_y.shape
cen_z = part_z.sum()/part_z.shape
delta_x = 1./128
Left = nar([ bd(pos.min(), delta_x) for pos in [part_x,part_y,part_z]])
Right = nar([ bu(pos.max(), delta_x) for pos in [part_x,part_y,part_z]])
Cen = 0.5*(Left+Right)
proj = ds.proj('density',0)
resolution = 128
frb = proj.to_frb(1.0,resolution)
y_coord = int(cen_y*resolution)
z_coord = int(cen_z*resolution)
half_line_width = int(0.25/4.6*resolution) #half line width
yi = y_coord-half_line_width
yf = y_coord+half_line_width
density_stripe = frb['density'][z_coord,yi:yf]
y_stripe = (frb['y'][z_coord,yi:yf].v- cen_y.v) *4.6
plt.clf()
plt.plot(y_stripe,density_stripe)
plt.ylabel(r'$\Sigma[code]$')
plt.xlabel(r'$y [pc]$')
outname = prefix+".png"
plt.savefig(outname)
plt.clf()
den =copy.copy(frb['density'].v)
den[z_coord,yi:yf] = den.max()
plt.imshow(np.log10(den),origin='lower', cmap='gray')
plt.savefig("%s_stripe_loc.png"%prefix)
print 'test.png'
print outname
def prepositions(dirname, target_frame, source_indices, prefix=None, extra_cuts=None,
streamlines=False):
"""from clump_particles, dave callback."""
field = 'density'
ds = yt.load('%s/DD%04d/data%04d'%(dirname,target_frame,target_frame))
reg = ds.all_data()
#source_indices = source_region['particle_index']
mask_to_get = na.zeros(source_indices.shape, dtype='int32')
found_any, mask = particle_ops.mask_particles(
source_indices.astype('int64'), reg['particle_index'].astype('int64'), mask_to_get)
part_x = reg['particle_position_x'][mask==1]
part_y = reg['particle_position_y'][mask==1]
part_z = reg['particle_position_z'][mask==1]
index = reg['particle_index'][mask==1]
if extra_cuts is not None:
if extra_cuts == 80:
""" how to pass in this complex logic?"""
keep_low_x = part_x < 0.5
print "shape", part_x.shape, keep_low_x.sum()
part_x = part_x[ keep_low_x]
part_y = part_y[ keep_low_x]
part_z = part_z[ keep_low_x]
index = index[keep_low_x]
cen_x = part_x.sum()/part_x.shape
cen_y = part_y.sum()/part_y.shape
cen_z = part_z.sum()/part_z.shape
delta_x = 1./128
Left = nar([ bd(pos.min(), delta_x) for pos in [part_x,part_y,part_z]])
Right = nar([ bu(pos.max(), delta_x) for pos in [part_x,part_y,part_z]])
Cen = 0.5*(Left+Right)
new_reg = ds.region(Cen,Left,Right)
for ax in [0,1,2]:
proj = ds.proj(field,ax,data_source=new_reg,center=[0.5]*3)
#proj = ds.proj(field,ax,center=[0.5]*3)
xi= proj.ds.coordinates.x_axis[ax]
yi= proj.ds.coordinates.y_axis[ax]
axis_names = ds.coordinates.axis_name
xv = "velocity_%s" % (axis_names[xi])
yv = "velocity_%s" % (axis_names[yi])
pw = proj.to_pw(center=[0.5]*3)
pw.set_cmap('density','gray')
pw.annotate_sphere([cen_x,cen_y,cen_z], 0.01, circle_args={'color':'r'})
#pw.annotate_dave_particles(1.0, indices = index, col='y')
if streamlines:
pw.annotate_streamlines(xv,yv,factor=1, density = 4)
annotate_box(pw,[Left[xi],Left[yi]],[Right[xi],Right[yi]], plot_args={'color':'r'})
print pw.save(prefix)
def target_particle_volume(field, data):
#pdb.set_trace()
target_indices = data.get_field_parameter('target_indices')
blank = np.zeros(data.ActiveDimensions, dtype='float64')
if type(target_indices) == float:
return blank
if data.NumberOfParticles == 0: return blank
mask_to_get = data.get_field_parameter('mask_to_get')
my_indices = data['particle_index'].astype('int64')
print("target_particle_volume nparticles %d" % my_indices.size)
found_any, mask = particle_ops.mask_particles(target_indices, my_indices,
mask_to_get)
data.set_field_parameter('mask_to_get',
mask_to_get) #keeping the mask is faster
pos_to_get = data['particle_position'][mask == 1]
d = data.deposit(pos_to_get, method="count")
d = data.ds.arr(d, input_units="cm**-3")
mask = d > 0
d[mask] = data['cell_volume'][mask]
return d
right_edge=loc + 1.5 * min_dx)
indices_late, xpos_late, ypos_late, zpos_late = clump_particles.particles_from_clump(
region)
print indices_late.size
if 0:
""" make a movie with the particles. Stride 64 over particles to make it go."""
#indices_0360 = fPickle.load('p19_u02d_0360_indices_late.pickle')
for frame in [200]: #range(0,370,10):
setname = template % (frame, frame)
ds = yt.load(sggetname)
if 1:
mask_to_get = na.zeros(self.indices.shape, dtype='int32')
found_any, mask = particle_ops.mask_particles(
self.indices.astype('int64'),
reg['particle_index'].astype('int64'), mask_to_get)
region = ds.region
if 0:
proj_full = ds.proj('density', 2,
center='c') #width = (1.0,'code_length'))
pw_full = proj_full.to_pw(center='c', width=(1.0, 'code_length'))
pw_full.annotate_dave_particles(1.0, col='r', indices=indices_late)
pw_full.set_cmap('density', 'gray')
pw_full.save('u02d_early_peak_%04d' % frame)
if 0:
ad = ds.all_data()
mask_to_get = np.zeros(
bad_index = np.where(my_indices==bad_id)
if 'gtots' not in dir():
gtots = this_looper.snaps[60][31].ds.index.grids[66]
snap = this_looper.snaps[60][31]
if 'getmask_pos' not in dir():
getmask_pos = data_region['particle_position'][bad_index]
getmask_vel = data_region['particle_velocity'][bad_index]
grid_index=75
print( 'got the right one: ',gtots['particle_index'][grid_index]==bad_id)
grid_pos = gtots['particle_position'][grid_index]
print( getmask_pos-grid_pos)
if 'found_any' not in dir():
found_any, mask = particle_ops.mask_particles(these_pids,my_indices,mask_to_get)
data_region['particle_index'][mask.astype('bool')] == bad_id
if 1:
index_3= np.where( snap.ind == bad_id)
print("pos: mask",getmask_pos)
print("pos: snap",snap.pos[index_3])
print("den: fv", snap.field_values['density'][index_3])
if 1:
thtr = this_looper.tr
track_id = np.where(thtr.particle_ids==1499257)
tr_density = thtr.c(31,'density')
this_density = tr_density[track_id,-1]
#print("The density for that particle",this_density)
print("The density for that particle",thtr.p([bad_id],'density'))
def __call__(self, plot):
data = plot.data
if iterable(self.width):
self.width = np.float64(plot.data.ds.quan(self.width[0], self.width[1]))
# we construct a recantangular prism
x0, x1 = plot.xlim
y0, y1 = plot.ylim
xx0, xx1 = plot._axes.get_xlim()
yy0, yy1 = plot._axes.get_ylim()
if self.bool is None:
reg = self._get_region((x0,x1), (y0,y1), plot.data.axis, data)
else:
reg = self.bool
ax = data.axis
xax = plot.data.ds.coordinates.x_axis[ax]
yax = plot.data.ds.coordinates.y_axis[ax]
axis_names = plot.data.ds.coordinates.axis_name
field_x = "particle_position_%s" % axis_names[xax]
field_y = "particle_position_%s" % axis_names[yax]
pt = self.ptype
shifted_field_x = reg[pt, field_x]
shifted_field_y = reg[pt, field_y]
shifted_field = [shifted_field_x, shifted_field_y]
lower_lim = data.ds.arr([xx0,yy0],'code_length')
upper_lim = data.ds.arr([xx1,yy1],'code_length')
dx_min = data.ds.index.get_smallest_dx()*0.1
for ndim,dim in enumerate([xax,yax]):
print("SHIFT", ndim, dim)
if data.ds.periodicity[dim]:
#If the plot is to the right of the domain
delta = upper_lim[ndim] - data.ds.domain_right_edge[dim]
if delta > dx_min:
delta = delta + data.ds.domain_left_edge[dim]
particles_to_shift = np.where(shifted_field[ndim] < delta)
shifted_field[ndim][particles_to_shift] += data.ds.domain_width[dim]
#If the plot is to the left
delta = data.ds.domain_left_edge[dim] - lower_lim[ndim]
if delta > dx_min:
delta = data.ds.domain_right_edge[dim] - delta
particles_to_shift = np.where(shifted_field[ndim] > delta)
shifted_field[ndim][particles_to_shift] -= data.ds.domain_width[dim]
gg = ( ( shifted_field_x >= x0 ) & ( shifted_field_x <= x1 )
& ( shifted_field_y >= y0 ) & ( shifted_field_y <= y1 ) )
print("CHECK", x0, x1, y0, y1, "npart", reg['particle_index'].size,"n(gg)", gg.sum())
#import pdb
#pdb.set_trace()
if self.indices != None:
print "particle callback warning: this might get expensive"
mask_to_get = na.zeros(self.indices.shape, dtype='int32')
found_any, mask = particle_ops.mask_particles(
self.indices.astype('int64'), reg['particle_index'].astype('int64'), mask_to_get)
gg = ( gg & (mask == 1) )
print "nparticles do it.", mask_to_get.sum()
if False:
if self.ptype is not None:
gg &= (reg["particle_type"] == self.ptype)
if gg.sum() == 0: return
if self.stars_only:
gg &= (reg["creation_time"] > 0.0)
if gg.sum() == 0: return
if self.dm_only:
gg &= (reg["creation_time"] <= 0.0)
if gg.sum() == 0: return
if self.minimum_mass is not None:
gg &= (reg["ParticleMassMsun"] >= self.minimum_mass)
if gg.sum() == 0: return
#plot._axes.hold(True)
px, py = self.convert_to_plot(plot,
[np.array(shifted_field_x[gg][::self.stride]),
np.array(shifted_field_y[gg][::self.stride])])
plot._axes.scatter(px, py, edgecolors='None', marker=self.marker,
s=self.p_size, c=self.color)
plot._axes.set_xlim(xx0,xx1)
plot._axes.set_ylim(yy0,yy1)
