def fake_random_ds(ndims,
peak_value=1.0,
fields=("density", "velocity_x", "velocity_y",
"velocity_z"),
units=('g/cm**3', 'cm/s', 'cm/s', 'cm/s'),
particle_fields=None,
particle_field_units=None,
negative=False,
nprocs=1,
particles=0,
length_unit=1.0,
unit_system="cgs",
bbox=None):
from yt.frontends.stream.api import load_uniform_grid
prng = RandomState(0x4d3d3d3)
if not iterable(ndims):
ndims = [ndims, ndims, ndims]
else:
assert (len(ndims) == 3)
if not iterable(negative):
negative = [negative for f in fields]
assert (len(fields) == len(negative))
offsets = []
for n in negative:
if n:
offsets.append(0.5)
else:
offsets.append(0.0)
data = {}
for field, offset, u in zip(fields, offsets, units):
v = (prng.random_sample(ndims) - offset) * peak_value
if field[0] == "all":
v = v.ravel()
data[field] = (v, u)
if particles:
if particle_fields is not None:
for field, unit in zip(particle_fields, particle_field_units):
if field in ('particle_position', 'particle_velocity'):
data['io', field] = (prng.random_sample(
(int(particles), 3)), unit)
else:
data['io',
field] = (prng.random_sample(size=int(particles)),
unit)
else:
for f in ('particle_position_%s' % ax for ax in 'xyz'):
data['io',
f] = (prng.random_sample(size=particles), 'code_length')
for f in ('particle_velocity_%s' % ax for ax in 'xyz'):
data['io',
f] = (prng.random_sample(size=particles) - 0.5, 'cm/s')
data['io', 'particle_mass'] = (prng.random_sample(particles), 'g')
ug = load_uniform_grid(data,
ndims,
length_unit=length_unit,
nprocs=nprocs,
unit_system=unit_system,
bbox=bbox)
return ug
def load_mocassin(path):
if not os.path.isdir(path):
raise OSError("%s is not a valid directory" % path)
domain_dims, domain_edges = _parse_grid0(path)
data = _parse_grid1(path, domain_dims)
data.update(_parse_plotout(path, domain_dims))
return load_uniform_grid(data, np.array(domain_dims), 1, bbox=domain_edges)
def test_magnetic_fields():
ddims = (16, 16, 16)
data1 = {
"magnetic_field_x": (np.random.random(size=ddims), "T"),
"magnetic_field_y": (np.random.random(size=ddims), "T"),
"magnetic_field_z": (np.random.random(size=ddims), "T")
}
data2 = {}
for field in data1:
data2[field] = (data1[field][0] * 1.0e4, "gauss")
ds1 = load_uniform_grid(data1, ddims, unit_system="cgs")
ds2 = load_uniform_grid(data2, ddims, unit_system="mks")
ds1.index
ds2.index
dd1 = ds1.all_data()
dd2 = ds2.all_data()
assert ds1.fields.gas.magnetic_field_strength.units == "gauss"
assert ds1.fields.gas.magnetic_field_poloidal.units == "gauss"
assert ds1.fields.gas.magnetic_field_toroidal.units == "gauss"
assert ds2.fields.gas.magnetic_field_strength.units == "T"
assert ds2.fields.gas.magnetic_field_poloidal.units == "T"
assert ds2.fields.gas.magnetic_field_toroidal.units == "T"
emag1 = (dd1["magnetic_field_x"]**2 + dd1["magnetic_field_y"]**2 +
dd1["magnetic_field_z"]**2) / (8.0 * np.pi)
emag1.convert_to_units("dyne/cm**2")
emag2 = (dd2["magnetic_field_x"]**2 + dd2["magnetic_field_y"]**2 +
dd2["magnetic_field_z"]**2) / (2.0 * mu_0)
emag2.convert_to_units("Pa")
assert_almost_equal(emag1, dd1["magnetic_energy"])
assert_almost_equal(emag2, dd2["magnetic_energy"])
assert str(emag1.units) == str(dd1["magnetic_energy"].units)
assert str(emag2.units) == str(dd2["magnetic_energy"].units)
assert_almost_equal(emag1.in_cgs(), emag2.in_cgs())
def test_nan_data():
data = np.random.random((16, 16, 16)) - 0.5
data[:9, :9, :9] = np.nan
data = {'density': data}
ds = load_uniform_grid(data, [16, 16, 16])
plot = SlicePlot(ds, 'z', 'density')
with tempfile.NamedTemporaryFile(suffix='png') as f:
plot.save(f.name)
def test_particles_outside_domain():
np.random.seed(0x4d3d3d3)
posx_arr = np.random.uniform(low=-1.6, high=1.5, size=1000)
posy_arr = np.random.uniform(low=-1.5, high=1.5, size=1000)
posz_arr = np.random.uniform(low=-1.5, high=1.5, size=1000)
dens_arr = np.random.random((16, 16, 16))
data = dict(density=dens_arr,
particle_position_x=posx_arr,
particle_position_y=posy_arr,
particle_position_z=posz_arr)
bbox = np.array([[-1.5, 1.5], [-1.5, 1.5], [-1.5, 1.5]])
ds = load_uniform_grid(data, (16, 16, 16), bbox=bbox, nprocs=4)
wh = (posx_arr < bbox[0, 0]).nonzero()[0]
assert wh.size == 1000 - ds.particle_type_counts['io']
ad = ds.all_data()
assert ds.particle_type_counts['io'] == ad['particle_position_x'].size
def test_clump_finding():
n_c = 8
n_p = 1
dims = (n_c, n_c, n_c)
density = np.ones(dims)
high_rho = 10.
# add a couple disconnected density enhancements
density[2, 2, 2] = high_rho
density[6, 6, 6] = high_rho
# put a particle at the center of one of them
dx = 1. / n_c
px = 2.5 * dx * np.ones(n_p)
data = {
"density": density,
"particle_mass": np.ones(n_p),
"particle_position_x": px,
"particle_position_y": px,
"particle_position_z": px
}
ds = load_uniform_grid(data, dims)
ad = ds.all_data()
master_clump = Clump(ad, ("gas", "density"))
master_clump.add_validator("min_cells", 1)
find_clumps(master_clump, 0.5, 2. * high_rho, 10.)
# there should be two children
assert_equal(len(master_clump.children), 2)
leaf_clumps = get_lowest_clumps(master_clump)
# two leaf clumps
assert_equal(len(leaf_clumps), 2)
# check some clump fields
assert_equal(master_clump.children[0]["density"][0].size, 1)
assert_equal(master_clump.children[0]["density"][0], ad["density"].max())
assert_equal(master_clump.children[0]["particle_mass"].size, 1)
assert_array_equal(master_clump.children[0]["particle_mass"],
ad["particle_mass"])
assert_equal(master_clump.children[1]["density"][0].size, 1)
assert_equal(master_clump.children[1]["density"][0], ad["density"].max())
assert_equal(master_clump.children[1]["particle_mass"].size, 0)
def test_ppv():
np.random.seed(seed=0x4d3d3d3)
dims = (8, 8, 128)
v_shift = 1.0e7 * u.cm / u.s
sigma_v = 2.0e7 * u.cm / u.s
T_0 = 1.0e8 * u.Kelvin
data = {
"density": (np.ones(dims), "g/cm**3"),
"temperature": (T_0.v * np.ones(dims), "K"),
"velocity_x": (np.zeros(dims), "cm/s"),
"velocity_y": (np.zeros(dims), "cm/s"),
"velocity_z": (np.random.normal(loc=v_shift.v,
scale=sigma_v.v,
size=dims), "cm/s")
}
ds = load_uniform_grid(data, dims)
cube = PPVCube(ds,
"z",
"density", (-300., 300., 1024, "km/s"),
dims=8,
thermal_broad=True)
dv = cube.dv
v_th = np.sqrt(2. * kboltz * T_0 / (56. * mh) +
2. * sigma_v**2).in_units("km/s")
a = cube.data.mean(axis=(0, 1)).v
b = dv * np.exp(-(
(cube.vmid + v_shift) / v_th)**2) / (np.sqrt(np.pi) * v_th)
assert_allclose_units(a, b, 1.0e-2)
E_0 = 6.8 * u.keV
cube.transform_spectral_axis(E_0.v, str(E_0.units))
dE = -cube.dv
delta_E = E_0 * v_th.in_cgs() / clight
E_shift = E_0 * (1. + v_shift / clight)
c = dE * np.exp(-(
(cube.vmid - E_shift) / delta_E)**2) / (np.sqrt(np.pi) * delta_E)
assert_allclose_units(a, c, 1.0e-2)
def export_dataset(self, fields=None, nprocs=1):
r"""Export a set of pixelized fields to an in-memory dataset that can be
analyzed as any other in yt. Unit information and other parameters (e.g.,
geometry, current_time, etc.) will be taken from the parent dataset.
Parameters
----------
fields : list of strings, optional
These fields will be pixelized and output. If "None", the keys of the
FRB will be used.
nprocs: integer, optional
If greater than 1, will create this number of subarrays out of data
Examples
--------
>>> import yt
>>> ds = yt.load("GasSloshing/sloshing_nomag2_hdf5_plt_cnt_0150")
>>> slc = ds.slice(2, 0.0)
>>> frb = slc.to_frb((500.,"kpc"), 500)
>>> ds2 = frb.export_dataset(fields=["density","temperature"], nprocs=32)
"""
nx, ny = self.buff_size
data = {}
if fields is None:
fields = list(self.keys())
for field in fields:
arr = self[field]
data[field] = (arr.d.T.reshape(nx, ny, 1), str(arr.units))
bounds = [b.in_units("code_length").v for b in self.bounds]
bbox = np.array([[bounds[0], bounds[1]], [bounds[2], bounds[3]],
[0.0, 1.0]])
return load_uniform_grid(
data,
[nx, ny, 1],
length_unit=self.ds.length_unit,
bbox=bbox,
sim_time=self.ds.current_time.in_units("s").v,
mass_unit=self.ds.mass_unit,
time_unit=self.ds.time_unit,
velocity_unit=self.ds.velocity_unit,
magnetic_unit=self.ds.magnetic_unit,
periodicity=(False, False, False),
geometry=self.ds.geometry,
nprocs=nprocs,
)
def __init__(self):
self.prng = RandomState(32)
self.kT = kT
self.Z = Z
self.O = O
self.Ca = Ca
nx = 128
ddims = (nx, nx, nx)
x, y, z = np.mgrid[-R:R:nx * 1j, -R:R:nx * 1j, -R:R:nx * 1j]
r = np.sqrt(x**2 + y**2 + z**2)
dens = np.zeros(ddims)
dens[r <= R] = rho_c * (1. + (r[r <= R] / r_c)**2)**(-1.5 * beta)
dens[r > R] = 0.0
pden = np.zeros(ddims)
x = r[r <= R] / r_s
pden[r <= R] = rho_s / (x * (1. + x)**2)
pden[r > R] = 0.0
temp = self.kT * K_per_keV * np.ones(ddims)
bbox = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, 0.5]])
velz = self.prng.normal(loc=v_shift, scale=v_width, size=ddims)
dm_disp = 1000. * np.ones(ddims) # km/s
data = {}
data["density"] = (dens, "g/cm**3")
data["dark_matter_density"] = (pden, "g/cm**3")
data["dark_matter_dispersion"] = (dm_disp, "km/s")
data["temperature"] = (temp, "K")
data["velocity_x"] = (np.zeros(ddims), "cm/s")
data["velocity_y"] = (np.zeros(ddims), "cm/s")
data["velocity_z"] = (velz, "cm/s")
data["oxygen"] = (self.O * np.ones(ddims), "Zsun")
data["calcium"] = (self.Ca * np.ones(ddims), "Zsun")
data["metallicity"] = (self.Z * np.ones(ddims), "Zsun")
self.ds = load_uniform_grid(data,
ddims,
length_unit=(2 * R, "Mpc"),
nprocs=64,
bbox=bbox)
def fake_random_ds(
ndims, peak_value = 1.0,
fields = ("density", "velocity_x", "velocity_y", "velocity_z"),
units = ('g/cm**3', 'cm/s', 'cm/s', 'cm/s'),
particle_fields=None, particle_field_units=None,
negative = False, nprocs = 1, particles = 0, length_unit=1.0):
from yt.frontends.stream.api import load_uniform_grid
if not iterable(ndims):
ndims = [ndims, ndims, ndims]
else:
assert(len(ndims) == 3)
if not iterable(negative):
negative = [negative for f in fields]
assert(len(fields) == len(negative))
offsets = []
for n in negative:
if n:
offsets.append(0.5)
else:
offsets.append(0.0)
data = {}
for field, offset, u in zip(fields, offsets, units):
v = (np.random.random(ndims) - offset) * peak_value
if field[0] == "all":
data['number_of_particles'] = v.size
v = v.ravel()
data[field] = (v, u)
if particles:
if particle_fields is not None:
for field, unit in zip(particle_fields, particle_field_units):
if field in ('particle_position', 'particle_velocity'):
data['io', field] = (np.random.random((particles, 3)), unit)
else:
data['io', field] = (np.random.random(size=particles), unit)
else:
for f in ('particle_position_%s' % ax for ax in 'xyz'):
data['io', f] = (np.random.random(size=particles), 'code_length')
for f in ('particle_velocity_%s' % ax for ax in 'xyz'):
data['io', f] = (np.random.random(size=particles) - 0.5, 'cm/s')
data['io', 'particle_mass'] = (np.random.random(particles), 'g')
data['number_of_particles'] = particles
ug = load_uniform_grid(data, ndims, length_unit=length_unit, nprocs=nprocs)
return ug
def __init__(self):
self.prng = RandomState(32)
self.kT = kT
self.Z = Z
self.O = O
self.Ca = Ca
nx = 128
ddims = (nx,nx,nx)
x, y, z = np.mgrid[-R:R:nx*1j,
-R:R:nx*1j,
-R:R:nx*1j]
r = np.sqrt(x**2+y**2+z**2)
dens = np.zeros(ddims)
dens[r <= R] = rho_c*(1.+(r[r <= R]/r_c)**2)**(-1.5*beta)
dens[r > R] = 0.0
pden = np.zeros(ddims)
x = r[r <= R]/r_s
pden[r <= R] = rho_s/(x*(1.+x)**2)
pden[r > R] = 0.0
temp = self.kT*K_per_keV*np.ones(ddims)
bbox = np.array([[-0.5,0.5],[-0.5,0.5],[-0.5,0.5]])
velz = self.prng.normal(loc=v_shift,scale=v_width,size=ddims)
dm_disp = 1000.*np.ones(ddims) # km/s
data = {}
data["density"] = (dens, "g/cm**3")
data["dark_matter_density"] = (pden, "g/cm**3")
data["dark_matter_dispersion"] = (dm_disp, "km/s")
data["temperature"] = (temp, "K")
data["velocity_x"] = (np.zeros(ddims), "cm/s")
data["velocity_y"] = (np.zeros(ddims), "cm/s")
data["velocity_z"] = (velz, "cm/s")
data["oxygen"] = (self.O*np.ones(ddims), "Zsun")
data["calcium"] = (self.Ca*np.ones(ddims), "Zsun")
data["metallicity"] = (self.Z*np.ones(ddims), "Zsun")
self.ds = load_uniform_grid(data, ddims, length_unit=(2*R, "Mpc"),
nprocs=64, bbox=bbox)
def export_dataset(self, fields=None, nprocs=1):
r"""Export a set of pixelized fields to an in-memory dataset that can be
analyzed as any other in yt. Unit information and other parameters (e.g.,
geometry, current_time, etc.) will be taken from the parent dataset.
Parameters
----------
fields : list of strings, optional
These fields will be pixelized and output. If "None", the keys of the
FRB will be used.
nprocs: integer, optional
If greater than 1, will create this number of subarrays out of data
Examples
--------
>>> import yt
>>> ds = yt.load("GasSloshing/sloshing_nomag2_hdf5_plt_cnt_0150")
>>> slc = ds.slice(2, 0.0)
>>> frb = slc.to_frb((500.,"kpc"), 500)
>>> ds2 = frb.export_dataset(fields=["density","temperature"], nprocs=32)
"""
nx, ny = self.buff_size
data = {}
if fields is None:
fields = list(self.keys())
for field in fields:
arr = self[field]
data[field] = (arr.d.T.reshape(nx,ny,1), str(arr.units))
bounds = [b.in_units("code_length").v for b in self.bounds]
bbox = np.array([[bounds[0],bounds[1]],[bounds[2],bounds[3]],[0.,1.]])
return load_uniform_grid(data, [nx,ny,1],
length_unit=self.ds.length_unit,
bbox=bbox,
sim_time=self.ds.current_time.in_units("s").v,
mass_unit=self.ds.mass_unit,
time_unit=self.ds.time_unit,
velocity_unit=self.ds.velocity_unit,
magnetic_unit=self.ds.magnetic_unit,
periodicity=(False,False,False),
geometry=self.ds.geometry,
nprocs=nprocs)
def setup_cluster():
R = 1000.
r_c = 100.
rho_c = 1.673e-26
beta = 1.
T0 = 4.
nx,ny,nz = 16,16,16
c = 0.17
a_c = 30.
a = 200.
v0 = 300.*cm_per_km
ddims = (nx,ny,nz)
x, y, z = np.mgrid[-R:R:nx*1j,
-R:R:ny*1j,
-R:R:nz*1j]
r = np.sqrt(x**2+y**2+z**2)
dens = np.zeros(ddims)
dens = rho_c*(1.+(r/r_c)**2)**(-1.5*beta)
temp = T0*K_per_keV/(1.+r/a)*(c+r/a_c)/(1.+r/a_c)
velz = v0*temp/(T0*K_per_keV)
data = {}
data["density"] = (dens, "g/cm**3")
data["temperature"] = (temp, "K")
data["velocity_x"] = (np.zeros(ddims), "cm/s")
data["velocity_y"] = (np.zeros(ddims), "cm/s")
data["velocity_z"] = (velz, "cm/s")
L = 2 * R * cm_per_kpc
bbox = np.array([[-0.5,0.5],[-0.5,0.5],[-0.5,0.5]]) * L
ds = load_uniform_grid(data, ddims, length_unit='cm', bbox=bbox)
ds.index
return ds
def setup_cluster():
R = 1000.
r_c = 100.
rho_c = 1.673e-26
beta = 1.
T0 = 4.
nx,ny,nz = 16,16,16
c = 0.17
a_c = 30.
a = 200.
v0 = 300.*cm_per_km
ddims = (nx,ny,nz)
x, y, z = np.mgrid[-R:R:nx*1j,
-R:R:ny*1j,
-R:R:nz*1j]
r = np.sqrt(x**2+y**2+z**2)
dens = np.zeros(ddims)
dens = rho_c*(1.+(r/r_c)**2)**(-1.5*beta)
temp = T0*K_per_keV/(1.+r/a)*(c+r/a_c)/(1.+r/a_c)
velz = v0*temp/(T0*K_per_keV)
data = {}
data["density"] = (dens, "g/cm**3")
data["temperature"] = (temp, "K")
data["velocity_x"] = (np.zeros(ddims), "cm/s")
data["velocity_y"] = (np.zeros(ddims), "cm/s")
data["velocity_z"] = (velz, "cm/s")
L = 2 * R * cm_per_kpc
bbox = np.array([[-0.5,0.5],[-0.5,0.5],[-0.5,0.5]]) * L
ds = load_uniform_grid(data, ddims, length_unit='cm', bbox=bbox)
ds.index
return ds
def test_amr_kdtree_coverage():
return #TESTDISABLED
domain_dims = (32, 32, 32)
data = np.zeros(domain_dims) + 0.25
fo = [
ic.CoredSphere(0.05, 0.3, [0.7, 0.4, 0.75], {"density": (0.25, 100.0)})
]
rc = [fm.flagging_method_registry["overdensity"](8.0)]
ug = load_uniform_grid({"density": data}, domain_dims, 1.0)
ds = refine_amr(ug, rc, fo, 5)
kd = AMRKDTree(ds)
volume = kd.count_volume()
yield assert_equal, volume, \
np.prod(ds.domain_right_edge - ds.domain_left_edge)
cells = kd.count_cells()
true_cells = ds.all_data().quantities['TotalQuantity']('Ones')[0]
yield assert_equal, cells, true_cells
# This largely reproduces the AMRKDTree.tree.check_tree() functionality
tree_ok = True
for node in kd.tree.trunk.depth_traverse():
if node.grid is None:
continue
grid = ds.index.grids[node.grid - kd._id_offset]
dds = grid.dds
gle = grid.LeftEdge
nle = node.get_left_edge()
nre = node.get_right_edge()
li = np.rint((nle - gle) / dds).astype('int32')
ri = np.rint((nre - gle) / dds).astype('int32')
dims = (ri - li).astype('int32')
tree_ok *= np.all(grid.LeftEdge <= nle)
tree_ok *= np.all(grid.RightEdge >= nre)
tree_ok *= np.all(dims > 0)
yield assert_equal, True, tree_ok
def test_amr_kdtree_coverage():
return #TESTDISABLED
domain_dims = (32, 32, 32)
data = np.zeros(domain_dims) + 0.25
fo = [ic.CoredSphere(0.05, 0.3, [0.7, 0.4, 0.75],
{"density": (0.25, 100.0)})]
rc = [fm.flagging_method_registry["overdensity"](8.0)]
ug = load_uniform_grid({"density": data}, domain_dims, 1.0)
ds = refine_amr(ug, rc, fo, 5)
kd = AMRKDTree(ds)
volume = kd.count_volume()
yield assert_equal, volume, \
np.prod(ds.domain_right_edge - ds.domain_left_edge)
cells = kd.count_cells()
true_cells = ds.all_data().quantities['TotalQuantity']('Ones')[0]
yield assert_equal, cells, true_cells
# This largely reproduces the AMRKDTree.tree.check_tree() functionality
tree_ok = True
for node in depth_traverse(kd.tree.trunk):
if node.grid is None:
continue
grid = ds.index.grids[node.grid - kd._id_offset]
dds = grid.dds
gle = grid.LeftEdge
nle = get_left_edge(node)
nre = get_right_edge(node)
li = np.rint((nle-gle)/dds).astype('int32')
ri = np.rint((nre-gle)/dds).astype('int32')
dims = (ri - li).astype('int32')
tree_ok *= np.all(grid.LeftEdge <= nle)
tree_ok *= np.all(grid.RightEdge >= nre)
tree_ok *= np.all(dims > 0)
yield assert_equal, True, tree_ok
def test_on_off_compare():
# fake density field that varies in the x-direction only
den = np.arange(32**3) / 32**2 + 1
den = den.reshape(32, 32, 32)
den = np.array(den, dtype=np.float64)
data = dict(density = (den, "g/cm**3"))
bbox = np.array([[-1.5, 1.5], [-1.5, 1.5], [-1.5, 1.5]])
ds = load_uniform_grid(data, den.shape, length_unit="Mpc", bbox=bbox, nprocs=64)
sl_on = SlicePlot(ds, "z", ["density"])
L = [0, 0, 1]
north_vector = [0, 1, 0]
sl_off = OffAxisSlicePlot(ds, L, 'density', center=[0,0,0], north_vector=north_vector)
assert_array_almost_equal(sl_on.frb['density'], sl_off.frb['density'])
sl_on.set_buff_size((800, 400))
sl_on._recreate_frb()
sl_off.set_buff_size((800, 400))
sl_off._recreate_frb()
assert_array_almost_equal(sl_on.frb['density'], sl_off.frb['density'])
def test_ppv_nothermalbroad():
np.random.seed(seed=0x4d3d3d3)
dims = (16, 16, 128)
v_shift = 1.0e6*u.cm/u.s
sigma_v = 2.0e6*u.cm/u.s
data = {"density":(np.ones(dims),"g/cm**3"),
"velocity_x":(np.zeros(dims),"cm/s"),
"velocity_y":(np.zeros(dims),"cm/s"),
"velocity_z":(np.random.normal(loc=v_shift.v,scale=sigma_v.v,size=dims), "cm/s")}
ds = load_uniform_grid(data, dims)
cube = PPVCube(ds, "z", "density", (-100., 100., 128, "km/s"),
dims=16, thermal_broad=False)
dv = cube.dv
v_noth = np.sqrt(2)*(sigma_v).in_units("km/s")
a = cube.data.mean(axis=(0,1)).v
b = dv*np.exp(-((cube.vmid+v_shift)/v_noth)**2)/(np.sqrt(np.pi)*v_noth)
assert_allclose_units(a, b, atol=5.0e-3)
def test_ppv():
np.random.seed(seed=0x4d3d3d3)
dims = (8,8,1024)
v_shift = 1.0e7*u.cm/u.s
sigma_v = 2.0e7*u.cm/u.s
T_0 = 1.0e8*u.Kelvin
data = {"density":(np.ones(dims),"g/cm**3"),
"temperature":(T_0.v*np.ones(dims), "K"),
"velocity_x":(np.zeros(dims),"cm/s"),
"velocity_y":(np.zeros(dims),"cm/s"),
"velocity_z":(np.random.normal(loc=v_shift.v,scale=sigma_v.v,size=dims), "cm/s")}
ds = load_uniform_grid(data, dims)
cube = PPVCube(ds, "z", "density", (-300., 300., 1024, "km/s"),
dims=8, thermal_broad=True)
dv = cube.dv
v_th = np.sqrt(2.*kboltz*T_0/(56.*mh) + 2.*sigma_v**2).in_units("km/s")
a = cube.data.mean(axis=(0,1)).v
b = dv*np.exp(-((cube.vmid+v_shift)/v_th)**2)/(np.sqrt(np.pi)*v_th)
yield assert_allclose_units, a, b, 1.0e-2
E_0 = 6.8*u.keV
cube.transform_spectral_axis(E_0.v, str(E_0.units))
dE = -cube.dv
delta_E = E_0*v_th.in_cgs()/clight
E_shift = E_0*(1.+v_shift/clight)
c = dE*np.exp(-((cube.vmid-E_shift)/delta_E)**2)/(np.sqrt(np.pi)*delta_E)
yield assert_allclose_units, a, c, 1.0e-2
def fake_random_ds(
ndims, peak_value = 1.0,
fields = ("density", "velocity_x", "velocity_y", "velocity_z"),
units = ('g/cm**3', 'cm/s', 'cm/s', 'cm/s'),
negative = False, nprocs = 1, particles = 0, length_unit=1.0):
from yt.data_objects.api import data_object_registry
from yt.frontends.stream.api import load_uniform_grid
if not iterable(ndims):
ndims = [ndims, ndims, ndims]
else:
assert(len(ndims) == 3)
if not iterable(negative):
negative = [negative for f in fields]
assert(len(fields) == len(negative))
offsets = []
for n in negative:
if n:
offsets.append(0.5)
else:
offsets.append(0.0)
data = {}
for field, offset, u in zip(fields, offsets, units):
v = (np.random.random(ndims) - offset) * peak_value
if field[0] == "all":
data['number_of_particles'] = v.size
v = v.ravel()
data[field] = (v, u)
if particles:
for f in ('particle_position_%s' % ax for ax in 'xyz'):
data[f] = (np.random.uniform(size = particles), 'code_length')
for f in ('particle_velocity_%s' % ax for ax in 'xyz'):
data[f] = (np.random.random(size = particles) - 0.5, 'cm/s')
data['particle_mass'] = (np.random.random(particles), 'g')
data['number_of_particles'] = particles
ug = load_uniform_grid(data, ndims, length_unit=length_unit, nprocs=nprocs)
return ug
def fake_random_ds(
ndims,
peak_value=1.0,
fields=("density", "velocity_x", "velocity_y", "velocity_z"),
units=("g/cm**3", "cm/s", "cm/s", "cm/s"),
particle_fields=None,
particle_field_units=None,
negative=False,
nprocs=1,
particles=0,
length_unit=1.0,
unit_system="cgs",
bbox=None,
):
from yt.frontends.stream.api import load_uniform_grid
prng = RandomState(0x4D3D3D3)
if not iterable(ndims):
ndims = [ndims, ndims, ndims]
else:
assert len(ndims) == 3
if not iterable(negative):
negative = [negative for f in fields]
assert len(fields) == len(negative)
offsets = []
for n in negative:
if n:
offsets.append(0.5)
else:
offsets.append(0.0)
data = {}
for field, offset, u in zip(fields, offsets, units):
v = (prng.random_sample(ndims) - offset) * peak_value
if field[0] == "all":
v = v.ravel()
data[field] = (v, u)
if particles:
if particle_fields is not None:
for field, unit in zip(particle_fields, particle_field_units):
if field in ("particle_position", "particle_velocity"):
data["io", field] = (prng.random_sample(
(int(particles), 3)), unit)
else:
data["io",
field] = (prng.random_sample(size=int(particles)),
unit)
else:
for f in (f"particle_position_{ax}" for ax in "xyz"):
data["io",
f] = (prng.random_sample(size=particles), "code_length")
for f in (f"particle_velocity_{ax}" for ax in "xyz"):
data["io",
f] = (prng.random_sample(size=particles) - 0.5, "cm/s")
data["io", "particle_mass"] = (prng.random_sample(particles), "g")
ug = load_uniform_grid(
data,
ndims,
length_unit=length_unit,
nprocs=nprocs,
unit_system=unit_system,
bbox=bbox,
)
return ug
def fake_vr_orientation_test_ds(N=96, scale=1):
"""
create a toy dataset that puts a sphere at (0,0,0), a single cube
on +x, two cubes on +y, and three cubes on +z in a domain from
[-1*scale,1*scale]**3. The lower planes
(x = -1*scale, y = -1*scale, z = -1*scale) are also given non-zero
values.
This dataset allows you to easily explore orientations and
handiness in VR and other renderings
Parameters
----------
N : integer
The number of cells along each direction
scale : float
A spatial scale, the domain boundaries will be multiplied by scale to
test datasets that have spatial different scales (e.g. data in CGS units)
"""
from yt.frontends.stream.api import load_uniform_grid
xmin = ymin = zmin = -1.0 * scale
xmax = ymax = zmax = 1.0 * scale
dcoord = (xmax - xmin) / N
arr = np.zeros((N, N, N), dtype=np.float64)
arr[:, :, :] = 1.e-4
bbox = np.array([[xmin, xmax], [ymin, ymax], [zmin, zmax]])
# coordinates -- in the notation data[i, j, k]
x = (np.arange(N) + 0.5) * dcoord + xmin
y = (np.arange(N) + 0.5) * dcoord + ymin
z = (np.arange(N) + 0.5) * dcoord + zmin
x3d, y3d, z3d = np.meshgrid(x, y, z, indexing="ij")
# sphere at the origin
c = np.array(
[0.5 * (xmin + xmax), 0.5 * (ymin + ymax), 0.5 * (zmin + zmax)])
r = np.sqrt((x3d - c[0])**2 + (y3d - c[1])**2 + (z3d - c[2])**2)
arr[r < 0.05] = 1.0
arr[abs(x3d - xmin) < 2 * dcoord] = 0.3
arr[abs(y3d - ymin) < 2 * dcoord] = 0.3
arr[abs(z3d - zmin) < 2 * dcoord] = 0.3
# single cube on +x
xc = 0.75 * scale
dx = 0.05 * scale
idx = np.logical_and(
np.logical_and(x3d > xc - dx, x3d < xc + dx),
np.logical_and(np.logical_and(y3d > -dx, y3d < dx),
np.logical_and(z3d > -dx, z3d < dx)))
arr[idx] = 1.0
# two cubes on +y
dy = 0.05 * scale
for yc in [0.65 * scale, 0.85 * scale]:
idx = np.logical_and(
np.logical_and(y3d > yc - dy, y3d < yc + dy),
np.logical_and(np.logical_and(x3d > -dy, x3d < dy),
np.logical_and(z3d > -dy, z3d < dy)))
arr[idx] = 0.8
# three cubes on +z
dz = 0.05 * scale
for zc in [0.5 * scale, 0.7 * scale, 0.9 * scale]:
idx = np.logical_and(
np.logical_and(z3d > zc - dz, z3d < zc + dz),
np.logical_and(np.logical_and(x3d > -dz, x3d < dz),
np.logical_and(y3d > -dz, y3d < dz)))
arr[idx] = 0.6
data = dict(density=(arr, "g/cm**3"))
ds = load_uniform_grid(data, arr.shape, bbox=bbox)
return ds
def test_particle_generator():
# First generate our dataset
domain_dims = (128, 128, 128)
dens = np.zeros(domain_dims) + 0.1
temp = 4.*np.ones(domain_dims)
fields = {"density": (dens, 'code_mass/code_length**3'),
"temperature": (temp, 'K')}
ug = load_uniform_grid(fields, domain_dims, 1.0)
fo = [ic.BetaModelSphere(1.0,0.1,0.5,[0.5,0.5,0.5],{"density":(10.0)})]
rc = [fm.flagging_method_registry["overdensity"](4.0)]
ds = refine_amr(ug, rc, fo, 3)
# Now generate particles from density
field_list = [("io", "particle_position_x"),
("io", "particle_position_y"),
("io", "particle_position_z"),
("io", "particle_index"),
("io", "particle_gas_density")]
num_particles = 1000000
field_dict = {("gas", "density"): ("io", "particle_gas_density")}
sphere = ds.sphere(ds.domain_center, 0.45)
particles1 = WithDensityParticleGenerator(ds, sphere, num_particles, field_list)
particles1.assign_indices()
particles1.map_grid_fields_to_particles(field_dict)
# Test to make sure we ended up with the right number of particles per grid
particles1.apply_to_stream()
particles_per_grid1 = [grid.NumberOfParticles for grid in ds.index.grids]
yield assert_equal, particles_per_grid1, particles1.NumberOfParticles
particles_per_grid1 = [len(grid["particle_position_x"]) for grid in ds.index.grids]
yield assert_equal, particles_per_grid1, particles1.NumberOfParticles
tags = uconcatenate([grid["particle_index"] for grid in ds.index.grids])
assert(np.unique(tags).size == num_particles)
# Set up a lattice of particles
pdims = np.array([64,64,64])
def new_indices() :
# We just add new indices onto the existing ones
return np.arange((np.product(pdims)))+num_particles
le = np.array([0.25,0.25,0.25])
re = np.array([0.75,0.75,0.75])
new_field_list = field_list + [("io", "particle_gas_temperature")]
new_field_dict = {("gas", "density"): ("io", "particle_gas_density"),
("gas", "temperature"): ("io", "particle_gas_temperature")}
particles2 = LatticeParticleGenerator(ds, pdims, le, re, new_field_list)
particles2.assign_indices(function=new_indices)
particles2.map_grid_fields_to_particles(new_field_dict)
#Test lattice positions
xpos = np.unique(particles2["io", "particle_position_x"])
ypos = np.unique(particles2["io", "particle_position_y"])
zpos = np.unique(particles2["io", "particle_position_z"])
xpred = np.linspace(le[0],re[0],num=pdims[0],endpoint=True)
ypred = np.linspace(le[1],re[1],num=pdims[1],endpoint=True)
zpred = np.linspace(le[2],re[2],num=pdims[2],endpoint=True)
assert_almost_equal( xpos, xpred)
assert_almost_equal( ypos, ypred)
assert_almost_equal( zpos, zpred)
#Test the number of particles again
particles2.apply_to_stream()
particles_per_grid2 = [grid.NumberOfParticles for grid in ds.index.grids]
yield assert_equal, particles_per_grid2, particles1.NumberOfParticles+particles2.NumberOfParticles
[grid.field_data.clear() for grid in ds.index.grids]
particles_per_grid2 = [len(grid["particle_position_x"]) for grid in ds.index.grids]
yield assert_equal, particles_per_grid2, particles1.NumberOfParticles+particles2.NumberOfParticles
#Test the uniqueness of tags
tags = np.concatenate([grid["particle_index"] for grid in ds.index.grids])
tags.sort()
yield assert_equal, tags, np.arange((np.product(pdims)+num_particles))
# Test that the old particles have zero for the new field
old_particle_temps = [grid["particle_gas_temperature"][:particles_per_grid1[i]]
for i, grid in enumerate(ds.index.grids)]
test_zeros = [np.zeros((particles_per_grid1[i]))
for i, grid in enumerate(ds.index.grids)]
yield assert_equal, old_particle_temps, test_zeros
#Now dump all of these particle fields out into a dict
pdata = {}
dd = ds.all_data()
for field in new_field_list :
pdata[field] = dd[field]
#Test the "from-list" generator and particle field clobber
particles3 = FromListParticleGenerator(ds, num_particles+np.product(pdims), pdata)
particles3.apply_to_stream(clobber=True)
#Test the number of particles again
particles_per_grid3 = [grid.NumberOfParticles for grid in ds.index.grids]
yield assert_equal, particles_per_grid3, particles1.NumberOfParticles+particles2.NumberOfParticles
particles_per_grid2 = [len(grid["particle_position_z"]) for grid in ds.index.grids]
yield assert_equal, particles_per_grid3, particles1.NumberOfParticles+particles2.NumberOfParticles
def setup_method(self, method):
x = np.arange(64).reshape((4, 4, 4))
data = dict(data=x)
y = load_uniform_grid(data, x.shape, 1)
self.x = x
self.y = y
def test_particle_generator():
# First generate our dataset
domain_dims = (32, 32, 32)
dens = np.zeros(domain_dims) + 0.1
temp = 4.0 * np.ones(domain_dims)
fields = {
"density": (dens, "code_mass/code_length**3"),
"temperature": (temp, "K")
}
ug = load_uniform_grid(fields, domain_dims, 1.0)
fo = [
ic.BetaModelSphere(1.0, 0.1, 0.5, [0.5, 0.5, 0.5], {"density": (10.0)})
]
rc = [fm.flagging_method_registry["overdensity"](4.0)]
ds = refine_amr(ug, rc, fo, 3)
# Now generate particles from density
field_list = [
("io", "particle_position_x"),
("io", "particle_position_y"),
("io", "particle_position_z"),
("io", "particle_index"),
("io", "particle_gas_density"),
]
num_particles = 10000
field_dict = {("gas", "density"): ("io", "particle_gas_density")}
sphere = ds.sphere(ds.domain_center, 0.45)
particles1 = WithDensityParticleGenerator(ds, sphere, num_particles,
field_list)
particles1.assign_indices()
particles1.map_grid_fields_to_particles(field_dict)
# Test to make sure we ended up with the right number of particles per grid
particles1.apply_to_stream()
particles_per_grid1 = [grid.NumberOfParticles for grid in ds.index.grids]
assert_equal(particles_per_grid1, particles1.NumberOfParticles)
particles_per_grid1 = [
len(grid["particle_position_x"]) for grid in ds.index.grids
]
assert_equal(particles_per_grid1, particles1.NumberOfParticles)
tags = uconcatenate([grid["particle_index"] for grid in ds.index.grids])
assert np.unique(tags).size == num_particles
del tags
# Set up a lattice of particles
pdims = np.array([32, 32, 32])
def new_indices():
# We just add new indices onto the existing ones
return np.arange((np.product(pdims))) + num_particles
le = np.array([0.25, 0.25, 0.25])
re = np.array([0.75, 0.75, 0.75])
particles2 = LatticeParticleGenerator(ds, pdims, le, re, field_list)
particles2.assign_indices(function=new_indices)
particles2.map_grid_fields_to_particles(field_dict)
# Test lattice positions
xpos = np.unique(particles2["io", "particle_position_x"])
ypos = np.unique(particles2["io", "particle_position_y"])
zpos = np.unique(particles2["io", "particle_position_z"])
xpred = np.linspace(le[0], re[0], num=pdims[0], endpoint=True)
ypred = np.linspace(le[1], re[1], num=pdims[1], endpoint=True)
zpred = np.linspace(le[2], re[2], num=pdims[2], endpoint=True)
assert_almost_equal(xpos, xpred)
assert_almost_equal(ypos, ypred)
assert_almost_equal(zpos, zpred)
del xpos, ypos, zpos
del xpred, ypred, zpred
# Test the number of particles again
particles2.apply_to_stream()
particles_per_grid2 = [grid.NumberOfParticles for grid in ds.index.grids]
assert_equal(particles_per_grid2,
particles1.NumberOfParticles + particles2.NumberOfParticles)
[grid.field_data.clear() for grid in ds.index.grids]
particles_per_grid2 = [
len(grid["particle_position_x"]) for grid in ds.index.grids
]
assert_equal(particles_per_grid2,
particles1.NumberOfParticles + particles2.NumberOfParticles)
# Test the uniqueness of tags
tags = np.concatenate([grid["particle_index"] for grid in ds.index.grids])
tags.sort()
assert_equal(tags, np.arange((np.product(pdims) + num_particles)))
del tags
# Now dump all of these particle fields out into a dict
pdata = {}
dd = ds.all_data()
for field in field_list:
pdata[field] = dd[field]
# Test the "from-list" generator and particle field overwrite
num_particles3 = num_particles + np.product(pdims)
particles3 = FromListParticleGenerator(ds, num_particles3, pdata)
particles3.apply_to_stream(overwrite=True)
# Test the number of particles again
particles_per_grid3 = [grid.NumberOfParticles for grid in ds.index.grids]
assert_equal(particles_per_grid3,
particles1.NumberOfParticles + particles2.NumberOfParticles)
particles_per_grid2 = [
len(grid["particle_position_z"]) for grid in ds.index.grids
]
assert_equal(particles_per_grid3,
particles1.NumberOfParticles + particles2.NumberOfParticles)
assert_equal(particles_per_grid2, particles_per_grid3)
# Test adding in particles with a different particle type
num_star_particles = 20000
pdata2 = {
("star", "particle_position_x"):
np.random.uniform(size=num_star_particles),
("star", "particle_position_y"):
np.random.uniform(size=num_star_particles),
("star", "particle_position_z"):
np.random.uniform(size=num_star_particles),
}
particles4 = FromListParticleGenerator(ds,
num_star_particles,
pdata2,
ptype="star")
particles4.apply_to_stream()
dd = ds.all_data()
assert dd["star", "particle_position_x"].size == num_star_particles
assert dd["io", "particle_position_x"].size == num_particles3
assert dd[
"all",
"particle_position_x"].size == num_star_particles + num_particles3
del pdata
del pdata2
del ds
del particles1
del particles2
del particles4
del fields
del dens
del temp
def test_particle_generator():
# First generate our pf
domain_dims = (128, 128, 128)
dens = np.zeros(domain_dims) + 0.1
temp = 4. * np.ones(domain_dims)
fields = {
"density": (dens, 'code_mass/code_length**3'),
"temperature": (temp, 'K')
}
ug = load_uniform_grid(fields, domain_dims, 1.0)
fo = [
ic.BetaModelSphere(1.0, 0.1, 0.5, [0.5, 0.5, 0.5], {"density": (10.0)})
]
rc = [fm.flagging_method_registry["overdensity"](4.0)]
ds = refine_amr(ug, rc, fo, 3)
# Now generate particles from density
field_list = [("io", "particle_position_x"), ("io", "particle_position_y"),
("io", "particle_position_z"), ("io", "particle_index"),
("io", "particle_gas_density")]
num_particles = 1000000
field_dict = {("gas", "density"): ("io", "particle_gas_density")}
sphere = ds.sphere(ds.domain_center, 0.45)
particles1 = WithDensityParticleGenerator(ds, sphere, num_particles,
field_list)
particles1.assign_indices()
particles1.map_grid_fields_to_particles(field_dict)
# Test to make sure we ended up with the right number of particles per grid
particles1.apply_to_stream()
particles_per_grid1 = [grid.NumberOfParticles for grid in ds.index.grids]
yield assert_equal, particles_per_grid1, particles1.NumberOfParticles
particles_per_grid1 = [
len(grid["particle_position_x"]) for grid in ds.index.grids
]
yield assert_equal, particles_per_grid1, particles1.NumberOfParticles
tags = uconcatenate([grid["particle_index"] for grid in ds.index.grids])
assert (np.unique(tags).size == num_particles)
# Set up a lattice of particles
pdims = np.array([64, 64, 64])
def new_indices():
# We just add new indices onto the existing ones
return np.arange((np.product(pdims))) + num_particles
le = np.array([0.25, 0.25, 0.25])
re = np.array([0.75, 0.75, 0.75])
new_field_list = field_list + [("io", "particle_gas_temperature")]
new_field_dict = {
("gas", "density"): ("io", "particle_gas_density"),
("gas", "temperature"): ("io", "particle_gas_temperature")
}
particles2 = LatticeParticleGenerator(ds, pdims, le, re, new_field_list)
particles2.assign_indices(function=new_indices)
particles2.map_grid_fields_to_particles(new_field_dict)
#Test lattice positions
xpos = np.unique(particles2["io", "particle_position_x"])
ypos = np.unique(particles2["io", "particle_position_y"])
zpos = np.unique(particles2["io", "particle_position_z"])
xpred = np.linspace(le[0], re[0], num=pdims[0], endpoint=True)
ypred = np.linspace(le[1], re[1], num=pdims[1], endpoint=True)
zpred = np.linspace(le[2], re[2], num=pdims[2], endpoint=True)
assert_almost_equal(xpos, xpred)
assert_almost_equal(ypos, ypred)
assert_almost_equal(zpos, zpred)
#Test the number of particles again
particles2.apply_to_stream()
particles_per_grid2 = [grid.NumberOfParticles for grid in ds.index.grids]
yield assert_equal, particles_per_grid2, particles1.NumberOfParticles + particles2.NumberOfParticles
[grid.field_data.clear() for grid in ds.index.grids]
particles_per_grid2 = [
len(grid["particle_position_x"]) for grid in ds.index.grids
]
yield assert_equal, particles_per_grid2, particles1.NumberOfParticles + particles2.NumberOfParticles
#Test the uniqueness of tags
tags = np.concatenate([grid["particle_index"] for grid in ds.index.grids])
tags.sort()
yield assert_equal, tags, np.arange((np.product(pdims) + num_particles))
# Test that the old particles have zero for the new field
old_particle_temps = [
grid["particle_gas_temperature"][:particles_per_grid1[i]]
for i, grid in enumerate(ds.index.grids)
]
test_zeros = [
np.zeros((particles_per_grid1[i]))
for i, grid in enumerate(ds.index.grids)
]
yield assert_equal, old_particle_temps, test_zeros
#Now dump all of these particle fields out into a dict
pdata = {}
dd = ds.all_data()
for field in new_field_list:
pdata[field] = dd[field]
#Test the "from-list" generator and particle field clobber
particles3 = FromListParticleGenerator(ds,
num_particles + np.product(pdims),
pdata)
particles3.apply_to_stream(clobber=True)
#Test the number of particles again
particles_per_grid3 = [grid.NumberOfParticles for grid in ds.index.grids]
yield assert_equal, particles_per_grid3, particles1.NumberOfParticles + particles2.NumberOfParticles
particles_per_grid2 = [
len(grid["particle_position_z"]) for grid in ds.index.grids
]
yield assert_equal, particles_per_grid3, particles1.NumberOfParticles + particles2.NumberOfParticles
#cube = cube.sum(axis=0)
# Indices for main NH3 component only
# Cube is in vyx format
i1 = 325
i2 = 450
cube = [i1:i2,:,:]
#Log transform the data in order to get on a viewable scale
cube = np.log(cube)
# Masking out nan elemenst
cube[np.isnan(cube)] = np.nanmin(cube)
# Loading data into yt structure
data = dict(Density = cube)
pf = load_uniform_grid(data, cube.shape, 9e16)
# Set the min/max to the data set (in units of log(I))
mi,ma = -2.,0.98
# Define a colour transfer function.
tf = ColorTransferFunction((mi, ma))
nLayer = 10
tf.add_layers(nLayer, w=0.005,colormap='gist_rainbow',
alpha = np.logspace(-1.0,0,nLayer))
nStep = 60 # Number of frames in the movie
phiarray = np.linspace(0,2*np.pi,nStep)
count = 0
for phi in phiarray:
vel_tot0 = np.sqrt(
np.power(velx0, 2.0) + np.power(vely0, 2.0) + np.power(velz0, 2.0))
rho0 = np.exp(lnrho0)
rho = np.exp(lnrho)
# Import arrays in yt
data = dict(Density=rho,
Velocity_x=velx,
Velocity_y=vely,
Velocity_z=velz,
Velocity=vel_tot)
bbox = np.array([[-Lbox / 2.0, Lbox / 2.0], [-Lbox / 2.0, Lbox / 2.0],
[-Lbox / 2.0, Lbox / 2.0]])
pf = load_uniform_grid(data, rho.shape, unit_lenght, bbox=bbox)
#pc = PlotCollection(pf, [0.0, 0.0, 0.0])
'''
#Save slice plots
SlicePlot(pf, 'x', 'Density').save()
SlicePlot(pf, 'y', 'Density').save()
SlicePlot(pf, 'z', 'Density').save()
SlicePlot(pf, 'x', 'Velocity').save()
SlicePlot(pf, 'y', 'Velocity').save()
SlicePlot(pf, 'z', 'Velocity').save()
SlicePlot(pf, 'x', 'Velocity_x').save()
SlicePlot(pf, 'y', 'Velocity_x').save()
SlicePlot(pf, 'z', 'Velocity_x').save()
SlicePlot(pf, 'x', 'Velocity_y').save()
# Loading fits data
dir = '/srv/astro/erosolo/n253/cubes/newrelease/lines/robust/non_pbcor/'
tracer = 'hcn'
cube = fits.getdata(dir + 'ngc253_' + tracer + '_clean_RO.fits')
#ALMA data has a polarization axis. Collapse along it.
cube = cube.sum(axis=0)
#Log transform the data in order to get on a viewable scale
cube = np.log(cube)
# Masking out nan elements
cube[np.isnan(cube)] = np.nanmin(cube)
# Loading data into yt structure
data = dict(Density=cube)
pf = load_uniform_grid(data, cube.shape, 9e16)
# Set the min/max to the data set (in units of log(I))
mi, ma = -5.7, -1.76
# Define a colour transfer function.
tf = ColorTransferFunction((mi, ma))
nLayer = 10
tf.add_layers(nLayer,
w=0.005,
colormap='gist_rainbow',
alpha=np.logspace(-1.0, 0, nLayer))
nStep = 60 # Number of frames in the movie
phiarray = np.linspace(0, 2 * np.pi, nStep)
count = 0
def test_stream_particles() :
num_particles = 100000
domain_dims = (64, 64, 64)
dens = np.random.random(domain_dims)
x = np.random.uniform(size=num_particles)
y = np.random.uniform(size=num_particles)
z = np.random.uniform(size=num_particles)
m = np.ones((num_particles))
# Field operators and cell flagging methods
fo = []
fo.append(ic.TopHatSphere(0.1, [0.2,0.3,0.4],{"density": 2.0}))
fo.append(ic.TopHatSphere(0.05, [0.7,0.4,0.75],{"density": 20.0}))
rc = [fm.flagging_method_registry["overdensity"](1.0)]
# Check that all of this runs ok without particles
ug0 = load_uniform_grid({"density": dens}, domain_dims, 1.0, nprocs=8)
amr0 = refine_amr(ug0, rc, fo, 3)
grid_data = []
for grid in amr0.index.grids :
data = dict(left_edge = grid.LeftEdge,
right_edge = grid.RightEdge,
level = grid.Level,
dimensions = grid.ActiveDimensions,
number_of_particles = grid.NumberOfParticles)
for field in amr0.field_list :
data[field] = grid[field]
grid_data.append(data)
amr0 = load_amr_grids(grid_data, domain_dims, 1.0)
# Now add particles
fields1 = {"density": dens,
"particle_position_x": x,
"particle_position_y": y,
"particle_position_z": z,
"particle_mass": m,
"number_of_particles": num_particles}
fields2 = fields1.copy()
ug1 = load_uniform_grid(fields1, domain_dims, 1.0)
ug2 = load_uniform_grid(fields2, domain_dims, 1.0, nprocs=8)
# Check to make sure the number of particles is the same
number_of_particles1 = np.sum([grid.NumberOfParticles for grid in ug1.index.grids])
number_of_particles2 = np.sum([grid.NumberOfParticles for grid in ug2.index.grids])
yield assert_equal, number_of_particles1, num_particles
yield assert_equal, number_of_particles1, number_of_particles2
# Check to make sure the fields have been defined correctly
for ptype in ("all", "io"):
assert ug1._get_field_info(ptype, "particle_position_x").particle_type
assert ug1._get_field_info(ptype, "particle_position_y").particle_type
assert ug1._get_field_info(ptype, "particle_position_z").particle_type
assert ug1._get_field_info(ptype, "particle_mass").particle_type
assert not ug1._get_field_info("gas", "density").particle_type
for ptype in ("all", "io"):
assert ug2._get_field_info(ptype, "particle_position_x").particle_type
assert ug2._get_field_info(ptype, "particle_position_y").particle_type
assert ug2._get_field_info(ptype, "particle_position_z").particle_type
assert ug2._get_field_info(ptype, "particle_mass").particle_type
assert not ug2._get_field_info("gas", "density").particle_type
# Now refine this
amr1 = refine_amr(ug1, rc, fo, 3)
for field in sorted(ug1.field_list):
yield assert_equal, (field in amr1.field_list), True
grid_data = []
for grid in amr1.index.grids :
data = dict(left_edge = grid.LeftEdge,
right_edge = grid.RightEdge,
level = grid.Level,
dimensions = grid.ActiveDimensions,
number_of_particles = grid.NumberOfParticles)
for field in amr1.field_list :
data[field] = grid[field]
grid_data.append(data)
amr2 = load_amr_grids(grid_data, domain_dims, 1.0)
# Check everything again
number_of_particles1 = [grid.NumberOfParticles for grid in amr1.index.grids]
number_of_particles2 = [grid.NumberOfParticles for grid in amr2.index.grids]
yield assert_equal, np.sum(number_of_particles1), num_particles
yield assert_equal, number_of_particles1, number_of_particles2
assert amr1._get_field_info("all", "particle_position_x").particle_type
assert amr1._get_field_info("all", "particle_position_y").particle_type
assert amr1._get_field_info("all", "particle_position_z").particle_type
assert amr1._get_field_info("all", "particle_mass").particle_type
assert not amr1._get_field_info("gas", "density").particle_type
assert amr2._get_field_info("all", "particle_position_x").particle_type
assert amr2._get_field_info("all", "particle_position_y").particle_type
assert amr2._get_field_info("all", "particle_position_z").particle_type
assert amr2._get_field_info("all", "particle_mass").particle_type
assert not amr2._get_field_info("gas", "density").particle_type
velz = read_grid_dat("data/velz.dat", nx, ny, nz)
vel_tot = np.sqrt( np.power(velx,2.0) + np.power(vely,2.0) + np.power(velz,2.0) )
vel_tot0 = np.sqrt( np.power(velx0,2.0) + np.power(vely0,2.0) + np.power(velz0,2.0) )
rho0 = np.exp(lnrho0)
rho = np.exp(lnrho)
#Import arrays in yt
from yt.mods import *
from yt.frontends.stream.api import load_uniform_grid
data = dict(Density = rho, Velocity_x = velx, Velocity_y = vely, Velocity_z = velz, Velocity = vel_tot)
bbox = np.array([[-Lbox/2.0, Lbox/2.0], [-Lbox/2.0, Lbox/2.0], [-Lbox/2.0, Lbox/2.0]])
pf = load_uniform_grid(data, rho.shape, unit_lenght, bbox=bbox)
#pc = PlotCollection(pf, [0.0, 0.0, 0.0])
'''
#Save slice plots
SlicePlot(pf, 'x', 'Density').save()
SlicePlot(pf, 'y', 'Density').save()
SlicePlot(pf, 'z', 'Density').save()
SlicePlot(pf, 'x', 'Velocity').save()
SlicePlot(pf, 'y', 'Velocity').save()
SlicePlot(pf, 'z', 'Velocity').save()
SlicePlot(pf, 'x', 'Velocity_x').save()
SlicePlot(pf, 'y', 'Velocity_x').save()
SlicePlot(pf, 'z', 'Velocity_x').save()
SlicePlot(pf, 'x', 'Velocity_y').save()
def test_stream_particles():
num_particles = 100000
domain_dims = (64, 64, 64)
dens = np.random.random(domain_dims)
x = np.random.uniform(size=num_particles)
y = np.random.uniform(size=num_particles)
z = np.random.uniform(size=num_particles)
m = np.ones((num_particles))
# Field operators and cell flagging methods
fo = []
fo.append(ic.TopHatSphere(0.1, [0.2, 0.3, 0.4], {"density": 2.0}))
fo.append(ic.TopHatSphere(0.05, [0.7, 0.4, 0.75], {"density": 20.0}))
rc = [fm.flagging_method_registry["overdensity"](1.0)]
# Check that all of this runs ok without particles
ug0 = load_uniform_grid({"density": dens}, domain_dims, 1.0, nprocs=8)
amr0 = refine_amr(ug0, rc, fo, 3)
grid_data = []
for grid in amr0.index.grids:
data = dict(left_edge=grid.LeftEdge,
right_edge=grid.RightEdge,
level=grid.Level,
dimensions=grid.ActiveDimensions,
number_of_particles=grid.NumberOfParticles)
for field in amr0.field_list:
data[field] = grid[field]
grid_data.append(data)
amr0 = load_amr_grids(grid_data, domain_dims, 1.0)
# Now add particles
fields1 = {
"density": dens,
"particle_position_x": x,
"particle_position_y": y,
"particle_position_z": z,
"particle_mass": m,
"number_of_particles": num_particles
}
fields2 = fields1.copy()
ug1 = load_uniform_grid(fields1, domain_dims, 1.0)
ug2 = load_uniform_grid(fields2, domain_dims, 1.0, nprocs=8)
# Check to make sure the number of particles is the same
number_of_particles1 = np.sum(
[grid.NumberOfParticles for grid in ug1.index.grids])
number_of_particles2 = np.sum(
[grid.NumberOfParticles for grid in ug2.index.grids])
yield assert_equal, number_of_particles1, num_particles
yield assert_equal, number_of_particles1, number_of_particles2
# Check to make sure the fields have been defined correctly
for ptype in ("all", "io"):
assert ug1._get_field_info(ptype, "particle_position_x").particle_type
assert ug1._get_field_info(ptype, "particle_position_y").particle_type
assert ug1._get_field_info(ptype, "particle_position_z").particle_type
assert ug1._get_field_info(ptype, "particle_mass").particle_type
assert not ug1._get_field_info("gas", "density").particle_type
for ptype in ("all", "io"):
assert ug2._get_field_info(ptype, "particle_position_x").particle_type
assert ug2._get_field_info(ptype, "particle_position_y").particle_type
assert ug2._get_field_info(ptype, "particle_position_z").particle_type
assert ug2._get_field_info(ptype, "particle_mass").particle_type
assert not ug2._get_field_info("gas", "density").particle_type
# Now refine this
amr1 = refine_amr(ug1, rc, fo, 3)
for field in sorted(ug1.field_list):
yield assert_equal, (field in amr1.field_list), True
grid_data = []
for grid in amr1.index.grids:
data = dict(left_edge=grid.LeftEdge,
right_edge=grid.RightEdge,
level=grid.Level,
dimensions=grid.ActiveDimensions,
number_of_particles=grid.NumberOfParticles)
for field in amr1.field_list:
data[field] = grid[field]
grid_data.append(data)
amr2 = load_amr_grids(grid_data, domain_dims, 1.0)
# Check everything again
number_of_particles1 = [
grid.NumberOfParticles for grid in amr1.index.grids
]
number_of_particles2 = [
grid.NumberOfParticles for grid in amr2.index.grids
]
yield assert_equal, np.sum(number_of_particles1), num_particles
yield assert_equal, number_of_particles1, number_of_particles2
assert amr1._get_field_info("all", "particle_position_x").particle_type
assert amr1._get_field_info("all", "particle_position_y").particle_type
assert amr1._get_field_info("all", "particle_position_z").particle_type
assert amr1._get_field_info("all", "particle_mass").particle_type
assert not amr1._get_field_info("gas", "density").particle_type
assert amr2._get_field_info("all", "particle_position_x").particle_type
assert amr2._get_field_info("all", "particle_position_y").particle_type
assert amr2._get_field_info("all", "particle_position_z").particle_type
assert amr2._get_field_info("all", "particle_mass").particle_type
assert not amr2._get_field_info("gas", "density").particle_type
print "YT, BITCHES!!!!"
result = self._y[view]
self._last = view
self._last_result = result
return result
if __name__ == "__main__":
from glue.core import Data, DataCollection
from glue.qt import GlueApplication
from yt.frontends.stream.api import load_uniform_grid
import numpy as np
from astropy.io import fits
data = fits.open("../paws_correct.fits", memmap=False)[0].data
data = np.squeeze(data)
x = data
shp = data.shape
pf = load_uniform_grid(dict(data=data), shp, 1)
d = Data(label="data")
d.add_component(YtComponent(x, pf, "data"), label="x")
dc = DataCollection(d)
ga = GlueApplication(dc)
ga.start()
def test_stream_particles():
num_particles = 100000
domain_dims = (64, 64, 64)
dens = np.random.random(domain_dims)
x = np.random.uniform(size=num_particles)
y = np.random.uniform(size=num_particles)
z = np.random.uniform(size=num_particles)
m = np.ones(num_particles)
# Field operators and cell flagging methods
fo = []
fo.append(ic.TopHatSphere(0.1, [0.2, 0.3, 0.4], {"density": 2.0}))
fo.append(ic.TopHatSphere(0.05, [0.7, 0.4, 0.75], {"density": 20.0}))
rc = [fm.flagging_method_registry["overdensity"](1.0)]
# Check that all of this runs ok without particles
ug0 = load_uniform_grid({"density": dens}, domain_dims, 1.0, nprocs=8)
amr0 = refine_amr(ug0, rc, fo, 3)
grid_data = []
for grid in amr0.index.grids:
data = dict(
left_edge=grid.LeftEdge,
right_edge=grid.RightEdge,
level=grid.Level,
dimensions=grid.ActiveDimensions,
)
for field in amr0.field_list:
data[field] = grid[field]
grid_data.append(data)
amr0 = load_amr_grids(grid_data, domain_dims)
# Now add particles
fields1 = {
"density": dens,
"particle_position_x": x,
"particle_position_y": y,
"particle_position_z": z,
"particle_mass": m,
}
fields2 = fields1.copy()
ug1 = load_uniform_grid(fields1, domain_dims, 1.0)
ug2 = load_uniform_grid(fields2, domain_dims, 1.0, nprocs=8)
# Check to make sure the number of particles is the same
number_of_particles1 = np.sum([grid.NumberOfParticles for grid in ug1.index.grids])
number_of_particles2 = np.sum([grid.NumberOfParticles for grid in ug2.index.grids])
assert_equal(number_of_particles1, num_particles)
assert_equal(number_of_particles1, number_of_particles2)
for grid in ug2.index.grids:
tot_parts = grid["io", "particle_position_x"].size
tot_all_parts = grid["all", "particle_position_x"].size
assert tot_parts == grid.NumberOfParticles
assert tot_all_parts == grid.NumberOfParticles
# Check to make sure the fields have been defined correctly
for ptype in ("all", "io"):
assert (
ug1._get_field_info(ptype, "particle_position_x").sampling_type
== "particle"
)
assert (
ug1._get_field_info(ptype, "particle_position_y").sampling_type
== "particle"
)
assert (
ug1._get_field_info(ptype, "particle_position_z").sampling_type
== "particle"
)
assert ug1._get_field_info(ptype, "particle_mass").sampling_type == "particle"
assert not ug1._get_field_info("gas", "density").sampling_type == "particle"
for ptype in ("all", "io"):
assert (
ug2._get_field_info(ptype, "particle_position_x").sampling_type
== "particle"
)
assert (
ug2._get_field_info(ptype, "particle_position_y").sampling_type
== "particle"
)
assert (
ug2._get_field_info(ptype, "particle_position_z").sampling_type
== "particle"
)
assert ug2._get_field_info(ptype, "particle_mass").sampling_type == "particle"
assert not ug2._get_field_info("gas", "density").sampling_type == "particle"
# Now refine this
amr1 = refine_amr(ug1, rc, fo, 3)
for field in sorted(ug1.field_list):
assert field in amr1.field_list
grid_data = []
for grid in amr1.index.grids:
data = dict(
left_edge=grid.LeftEdge,
right_edge=grid.RightEdge,
level=grid.Level,
dimensions=grid.ActiveDimensions,
)
for field in amr1.field_list:
if field[0] not in ("all", "nbody"):
data[field] = grid[field]
grid_data.append(data)
amr2 = load_amr_grids(grid_data, domain_dims)
# Check everything again
number_of_particles1 = [grid.NumberOfParticles for grid in amr1.index.grids]
number_of_particles2 = [grid.NumberOfParticles for grid in amr2.index.grids]
assert_equal(np.sum(number_of_particles1), num_particles)
assert_equal(number_of_particles1, number_of_particles2)
for grid in amr1.index.grids:
tot_parts = grid["io", "particle_position_x"].size
tot_all_parts = grid["all", "particle_position_x"].size
assert tot_parts == grid.NumberOfParticles
assert tot_all_parts == grid.NumberOfParticles
for grid in amr2.index.grids:
tot_parts = grid["io", "particle_position_x"].size
tot_all_parts = grid["all", "particle_position_x"].size
assert tot_parts == grid.NumberOfParticles
assert tot_all_parts == grid.NumberOfParticles
assert (
amr1._get_field_info("all", "particle_position_x").sampling_type == "particle"
)
assert (
amr1._get_field_info("all", "particle_position_y").sampling_type == "particle"
)
assert (
amr1._get_field_info("all", "particle_position_z").sampling_type == "particle"
)
assert amr1._get_field_info("all", "particle_mass").sampling_type == "particle"
assert not amr1._get_field_info("gas", "density").sampling_type == "particle"
assert (
amr2._get_field_info("all", "particle_position_x").sampling_type == "particle"
)
assert (
amr2._get_field_info("all", "particle_position_y").sampling_type == "particle"
)
assert (
amr2._get_field_info("all", "particle_position_z").sampling_type == "particle"
)
assert amr2._get_field_info("all", "particle_mass").sampling_type == "particle"
assert not amr2._get_field_info("gas", "density").sampling_type == "particle"
# Now perform similar checks, but with multiple particle types
num_dm_particles = 30000
xd = np.random.uniform(size=num_dm_particles)
yd = np.random.uniform(size=num_dm_particles)
zd = np.random.uniform(size=num_dm_particles)
md = np.ones(num_dm_particles)
num_star_particles = 20000
xs = np.random.uniform(size=num_star_particles)
ys = np.random.uniform(size=num_star_particles)
zs = np.random.uniform(size=num_star_particles)
ms = 2.0 * np.ones(num_star_particles)
dens = np.random.random(domain_dims)
fields3 = {
"density": dens,
("dm", "particle_position_x"): xd,
("dm", "particle_position_y"): yd,
("dm", "particle_position_z"): zd,
("dm", "particle_mass"): md,
("star", "particle_position_x"): xs,
("star", "particle_position_y"): ys,
("star", "particle_position_z"): zs,
("star", "particle_mass"): ms,
}
fields4 = fields3.copy()
ug3 = load_uniform_grid(fields3, domain_dims, 1.0)
ug4 = load_uniform_grid(fields4, domain_dims, 1.0, nprocs=8)
# Check to make sure the number of particles is the same
number_of_particles3 = np.sum([grid.NumberOfParticles for grid in ug3.index.grids])
number_of_particles4 = np.sum([grid.NumberOfParticles for grid in ug4.index.grids])
assert_equal(number_of_particles3, num_dm_particles + num_star_particles)
assert_equal(number_of_particles3, number_of_particles4)
for grid in ug4.index.grids:
tot_parts = grid["dm", "particle_position_x"].size
tot_parts += grid["star", "particle_position_x"].size
tot_all_parts = grid["all", "particle_position_x"].size
assert tot_parts == grid.NumberOfParticles
assert tot_all_parts == grid.NumberOfParticles
# Check to make sure the fields have been defined correctly
for ptype in ("dm", "star"):
assert (
ug3._get_field_info(ptype, "particle_position_x").sampling_type
== "particle"
)
assert (
ug3._get_field_info(ptype, "particle_position_y").sampling_type
== "particle"
)
assert (
ug3._get_field_info(ptype, "particle_position_z").sampling_type
== "particle"
)
assert ug3._get_field_info(ptype, "particle_mass").sampling_type == "particle"
assert (
ug4._get_field_info(ptype, "particle_position_x").sampling_type
== "particle"
)
assert (
ug4._get_field_info(ptype, "particle_position_y").sampling_type
== "particle"
)
assert (
ug4._get_field_info(ptype, "particle_position_z").sampling_type
== "particle"
)
assert ug4._get_field_info(ptype, "particle_mass").sampling_type == "particle"
# Now refine this
amr3 = refine_amr(ug3, rc, fo, 3)
for field in sorted(ug3.field_list):
assert field in amr3.field_list
grid_data = []
for grid in amr3.index.grids:
data = dict(
left_edge=grid.LeftEdge,
right_edge=grid.RightEdge,
level=grid.Level,
dimensions=grid.ActiveDimensions,
)
for field in amr3.field_list:
if field[0] not in ("all", "nbody"):
data[field] = grid[field]
grid_data.append(data)
amr4 = load_amr_grids(grid_data, domain_dims)
# Check everything again
number_of_particles3 = [grid.NumberOfParticles for grid in amr3.index.grids]
number_of_particles4 = [grid.NumberOfParticles for grid in amr4.index.grids]
assert_equal(np.sum(number_of_particles3), num_star_particles + num_dm_particles)
assert_equal(number_of_particles3, number_of_particles4)
for ptype in ("dm", "star"):
assert (
amr3._get_field_info(ptype, "particle_position_x").sampling_type
== "particle"
)
assert (
amr3._get_field_info(ptype, "particle_position_y").sampling_type
== "particle"
)
assert (
amr3._get_field_info(ptype, "particle_position_z").sampling_type
== "particle"
)
assert amr3._get_field_info(ptype, "particle_mass").sampling_type == "particle"
assert (
amr4._get_field_info(ptype, "particle_position_x").sampling_type
== "particle"
)
assert (
amr4._get_field_info(ptype, "particle_position_y").sampling_type
== "particle"
)
assert (
amr4._get_field_info(ptype, "particle_position_z").sampling_type
== "particle"
)
assert amr4._get_field_info(ptype, "particle_mass").sampling_type == "particle"
for grid in amr3.index.grids:
tot_parts = grid["dm", "particle_position_x"].size
tot_parts += grid["star", "particle_position_x"].size
tot_all_parts = grid["all", "particle_position_x"].size
assert tot_parts == grid.NumberOfParticles
assert tot_all_parts == grid.NumberOfParticles
for grid in amr4.index.grids:
tot_parts = grid["dm", "particle_position_x"].size
tot_parts += grid["star", "particle_position_x"].size
tot_all_parts = grid["all", "particle_position_x"].size
assert tot_parts == grid.NumberOfParticles
assert tot_all_parts == grid.NumberOfParticles
def test_beta_model():
import xspec
xspec.Fit.statMethod = "cstat"
xspec.Xset.addModelString("APECTHERMAL", "yes")
xspec.Fit.query = "yes"
xspec.Fit.method = ["leven", "10", "0.01"]
xspec.Fit.delta = 0.01
xspec.Xset.chatter = 5
my_prng = RandomState(24)
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
R = 1.0
r_c = 0.05
rho_c = 0.04 * mass_hydrogen_grams
beta = 1.
kT_sim = 6.0
v_shift = 4.0e7
v_width = 4.0e7
nx = 128
ddims = (nx, nx, nx)
x, y, z = np.mgrid[-R:R:nx * 1j, -R:R:nx * 1j, -R:R:nx * 1j]
r = np.sqrt(x**2 + y**2 + z**2)
dens = np.zeros(ddims)
dens[r <= R] = rho_c * (1. + (r[r <= R] / r_c)**2)**(-1.5 * beta)
dens[r > R] = 0.0
temp = kT_sim * K_per_keV * np.ones(ddims)
bbox = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, 0.5]])
velz = my_prng.normal(loc=v_shift, scale=v_width, size=ddims)
data = {}
data["density"] = (dens, "g/cm**3")
data["temperature"] = (temp, "K")
data["velocity_x"] = (np.zeros(ddims), "cm/s")
data["velocity_y"] = (np.zeros(ddims), "cm/s")
data["velocity_z"] = (velz, "cm/s")
ds = load_uniform_grid(data,
ddims,
length_unit=(2 * R, "Mpc"),
nprocs=64,
bbox=bbox)
A = 3000.
exp_time = 1.0e5
redshift = 0.05
nH_sim = 0.02
apec_model = XSpecThermalModel("bapec",
0.1,
11.5,
20000,
thermal_broad=True)
abs_model = XSpecAbsorbModel("TBabs", nH_sim)
sphere = ds.sphere("c", (0.5, "Mpc"))
mu_sim = -v_shift / 1.0e5
sigma_sim = v_width / 1.0e5
Z_sim = 0.3
thermal_model = ThermalPhotonModel(apec_model,
Zmet=Z_sim,
X_H=0.76,
prng=my_prng)
photons = PhotonList.from_scratch(sphere, redshift, A, exp_time,
thermal_model)
D_A = photons.parameters["FiducialAngularDiameterDistance"]
norm_sim = sphere.quantities.total_quantity("emission_measure")
norm_sim *= 1.0e-14 / (4 * np.pi * D_A * D_A * (1. + redshift) *
(1. + redshift))
norm_sim = float(norm_sim.in_cgs())
events = photons.project_photons("z",
responses=[arf, rmf],
absorb_model=abs_model,
convolve_energies=True,
prng=my_prng)
events.write_spectrum("beta_model_evt.pi", clobber=True)
s = xspec.Spectrum("beta_model_evt.pi")
s.ignore("**-0.5")
s.ignore("9.0-**")
m = xspec.Model("tbabs*bapec")
m.bapec.kT = 5.5
m.bapec.Abundanc = 0.25
m.bapec.norm = 1.0
m.bapec.Redshift = 0.05
m.bapec.Velocity = 300.0
m.TBabs.nH = 0.02
m.bapec.Velocity.frozen = False
m.bapec.Abundanc.frozen = False
m.bapec.Redshift.frozen = False
m.TBabs.nH.frozen = True
xspec.Fit.renorm()
xspec.Fit.nIterations = 100
xspec.Fit.perform()
kT = m.bapec.kT.values[0]
mu = (m.bapec.Redshift.values[0] - redshift) * ckms
Z = m.bapec.Abundanc.values[0]
sigma = m.bapec.Velocity.values[0]
norm = m.bapec.norm.values[0]
dkT = m.bapec.kT.sigma
dmu = m.bapec.Redshift.sigma * ckms
dZ = m.bapec.Abundanc.sigma
dsigma = m.bapec.Velocity.sigma
dnorm = m.bapec.norm.sigma
assert np.abs(mu - mu_sim) < dmu
assert np.abs(kT - kT_sim) < dkT
assert np.abs(Z - Z_sim) < dZ
assert np.abs(sigma - sigma_sim) < dsigma
assert np.abs(norm - norm_sim) < dnorm
xspec.AllModels.clear()
xspec.AllData.clear()
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_clump_finding():
n_c = 8
n_p = 1
dims = (n_c, n_c, n_c)
density = np.ones(dims)
high_rho = 10.0
# add a couple disconnected density enhancements
density[2, 2, 2] = high_rho
density[6, 6, 6] = high_rho
# put a particle at the center of one of them
dx = 1.0 / n_c
px = 2.5 * dx * np.ones(n_p)
data = {
"density": density,
"particle_mass": np.ones(n_p),
"particle_position_x": px,
"particle_position_y": px,
"particle_position_z": px,
}
ds = load_uniform_grid(data, dims)
ad = ds.all_data()
master_clump = Clump(ad, ("gas", "density"))
master_clump.add_validator("min_cells", 1)
def _total_volume(clump):
total_vol = clump.data.quantities.total_quantity(["cell_volume"
]).in_units("cm**3")
return "Cell Volume: %6e cm**3.", total_vol
add_clump_info("total_volume", _total_volume)
master_clump.add_info_item("total_volume")
find_clumps(master_clump, 0.5, 2.0 * high_rho, 10.0)
# there should be two children
assert_equal(len(master_clump.children), 2)
leaf_clumps = master_clump.leaves
for l in leaf_clumps:
keys = l.info.keys()
assert "total_cells" in keys
assert "cell_mass" in keys
assert "max_grid_level" in keys
assert "total_volume" in keys
# two leaf clumps
assert_equal(len(leaf_clumps), 2)
# check some clump fields
assert_equal(master_clump.children[0]["density"][0].size, 1)
assert_equal(master_clump.children[0]["density"][0], ad["density"].max())
assert_equal(master_clump.children[0]["particle_mass"].size, 1)
assert_array_equal(master_clump.children[0]["particle_mass"],
ad["particle_mass"])
assert_equal(master_clump.children[1]["density"][0].size, 1)
assert_equal(master_clump.children[1]["density"][0], ad["density"].max())
assert_equal(master_clump.children[1]["particle_mass"].size, 0)
# clean up global registry to avoid polluting other tests
del clump_info_registry["total_volume"]