def test_dlambda_extra_wide(self):
"""
Compare auto velocity against setting same dlambda with
min and max set extra wide.
"""
sg_auto = SpectrumGenerator(lambda_min='auto',
lambda_max='auto',
dlambda=1.0,
bin_space='velocity')
sg_auto.make_spectrum("ray.h5",
lines=self.line_list,
store_observables=True)
sg_comp = SpectrumGenerator(lambda_min=sg_auto.lambda_field[0],
lambda_max=sg_auto.lambda_field[-1],
n_lambda=sg_auto.lambda_field.size,
bin_space='velocity')
sg_comp.make_spectrum("ray.h5",
lines=self.line_list,
store_observables=True)
assert_allclose(
sg_auto.tau_field.sum(),
sg_comp.tau_field.sum(),
rtol=1e-7,
err_msg='Total tau disagrees with extra wide spectrum.')
def compare(self, new_result, old_result):
err_msg = "Total value for %s not equal." % (self.field, )
assert_allclose(new_result,
old_result,
10.**(-self.decimals),
err_msg=err_msg,
verbose=True)
def test_setting_lambda_max(self):
"""
Test setting an arbitrary lambda_max with auto-lambda.
"""
sg_auto = SpectrumGenerator(lambda_min='auto',
lambda_max='auto',
dlambda=1.0,
bin_space='velocity')
sg_auto.make_spectrum("ray.h5",
lines=self.line_list,
ly_continuum=False)
sg_comp = SpectrumGenerator(lambda_min='auto',
lambda_max=-10000.,
dlambda=1.0,
bin_space='velocity')
sg_comp.make_spectrum("ray.h5",
lines=self.line_list,
ly_continuum=False)
comp_lambda = sg_auto.lambda_field <= sg_comp.lambda_field[-1]
assert_allclose(sg_auto.tau_field[comp_lambda].sum(),
sg_comp.tau_field.sum())
def compare(self, new_result, old_result):
err_msg = f"Total value for {self.field} not equal."
assert_allclose(
new_result,
old_result,
10.0**(-self.decimals),
err_msg=err_msg,
verbose=True,
)
def test_disk():
ds = data_dir_load(disk)
assert_equal(str(ds), "disk.out1.00000")
dd = ds.all_data()
vol = (ds.domain_right_edge[0]**3 - ds.domain_left_edge[0]**3) / 3.0
vol *= np.cos(ds.domain_left_edge[1]) - np.cos(ds.domain_right_edge[1])
vol *= ds.domain_right_edge[2].v - ds.domain_left_edge[2].v
assert_allclose(dd.quantities.total_quantity("cell_volume"), vol)
for field in _fields_disk:
def field_func(name):
return dd[field]
yield GenericArrayTest(ds, field_func, args=[field])
def test_magnetic_units():
ds1 = load(plasma)
assert_allclose(ds1.magnetic_unit.value, 1.0)
assert str(ds1.magnetic_unit.units) == "T"
mag_unit1 = ds1.magnetic_unit.to("code_magnetic")
assert_allclose(mag_unit1.value, 1.0)
assert str(mag_unit1.units) == "code_magnetic"
ds2 = load(plasma, unit_system="cgs")
assert_allclose(ds2.magnetic_unit.value, 1.0e4)
assert str(ds2.magnetic_unit.units) == "G"
mag_unit2 = ds2.magnetic_unit.to("code_magnetic")
assert_allclose(mag_unit2.value, 1.0)
assert str(mag_unit2.units) == "code_magnetic"
def test_magnetic_units():
ds1 = load(sloshing)
assert_allclose(ds1.magnetic_unit.value, np.sqrt(4.0 * np.pi))
assert str(ds1.magnetic_unit.units) == "G"
mag_unit1 = ds1.magnetic_unit.to("code_magnetic")
assert_allclose(mag_unit1.value, 1.0)
assert str(mag_unit1.units) == "code_magnetic"
ds2 = load(sloshing, unit_system="mks")
assert_allclose(ds2.magnetic_unit.value, np.sqrt(4.0 * np.pi) * 1.0e-4)
assert str(ds2.magnetic_unit.units) == "T"
mag_unit2 = ds2.magnetic_unit.to("code_magnetic")
assert_allclose(mag_unit2.value, 1.0)
assert str(mag_unit2.units) == "code_magnetic"
def test_sample():
grid = {}
dims = np.array([64, 64, 64], dtype="int32")
inds = np.indices(dims)
grid["x"] = inds[0] + 0.5
grid["y"] = inds[1] + 0.5
grid["z"] = inds[2] + 0.5
num_particles = np.int64(1000)
xp = np.random.uniform(low=1.0, high=63.0, size=num_particles)
yp = np.random.uniform(low=1.0, high=63.0, size=num_particles)
zp = np.random.uniform(low=1.0, high=63.0, size=num_particles)
xfield = np.zeros((num_particles))
yfield = np.zeros((num_particles))
zfield = np.zeros((num_particles))
dx = 1.0
le = np.zeros((3))
CICSample_3(xp, yp, zp, xfield, num_particles, grid["x"], le, dims, dx)
CICSample_3(xp, yp, zp, yfield, num_particles, grid["y"], le, dims, dx)
CICSample_3(xp, yp, zp, zfield, num_particles, grid["z"], le, dims, dx)
assert_allclose(xp, xfield)
assert_allclose(yp, yfield)
assert_allclose(zp, zfield)
def test_setting_lambda_min(self):
"""
Test setting an arbitrary lambda_min with auto-lambda.
"""
sg_auto = SpectrumGenerator(lambda_min='auto',
lambda_max='auto',
dlambda=0.01)
sg_auto.make_spectrum("ray.h5",
lines=self.line_list,
ly_continuum=False)
sg_comp = SpectrumGenerator(lambda_min=1100,
lambda_max='auto',
dlambda=0.01)
sg_comp.make_spectrum("ray.h5",
lines=self.line_list,
ly_continuum=False)
comp_lambda = sg_auto.lambda_field >= sg_comp.lambda_field[0]
assert_allclose(sg_auto.tau_field[comp_lambda].sum(),
sg_comp.tau_field.sum())
def test_particle_phase_plot_semantics():
ds = load(tgal)
ad = ds.all_data()
dens_ex = ad.quantities.extrema(('Gas', 'density'))
temp_ex = ad.quantities.extrema(('Gas', 'temperature'))
plot = ParticlePlot(ds,
('Gas', 'density'),
('Gas', 'temperature'),
('Gas', 'particle_mass'))
plot.set_log('density', True)
plot.set_log('temperature', True)
p = plot.profile
# bin extrema are field extrema
assert dens_ex[0] - np.spacing(dens_ex[0]) == p.x_bins[0]
assert dens_ex[-1] + np.spacing(dens_ex[-1]) == p.x_bins[-1]
assert temp_ex[0] - np.spacing(temp_ex[0]) == p.y_bins[0]
assert temp_ex[-1] + np.spacing(temp_ex[-1]) == p.y_bins[-1]
# bins are evenly spaced in log space
logxbins = np.log10(p.x_bins)
dxlogxbins = logxbins[1:] - logxbins[:-1]
assert_allclose(dxlogxbins, dxlogxbins[0])
logybins = np.log10(p.y_bins)
dylogybins = logybins[1:] - logybins[:-1]
assert_allclose(dylogybins, dylogybins[0])
plot.set_log('density', False)
plot.set_log('temperature', False)
p = plot.profile
# bin extrema are field extrema
assert dens_ex[0] - np.spacing(dens_ex[0]) == p.x_bins[0]
assert dens_ex[-1] + np.spacing(dens_ex[-1]) == p.x_bins[-1]
assert temp_ex[0] - np.spacing(temp_ex[0]) == p.y_bins[0]
assert temp_ex[-1] + np.spacing(temp_ex[-1]) == p.y_bins[-1]
# bins are evenly spaced in log space
dxbins = p.x_bins[1:] - p.x_bins[:-1]
assert_allclose(dxbins, dxbins[0])
dybins = p.y_bins[1:] - p.y_bins[:-1]
assert_allclose(dybins, dybins[0])
def test_magnetic_code_units():
sqrt4pi = np.sqrt(4.0 * np.pi)
ddims = (16, ) * 3
data = {"density": (np.random.uniform(size=ddims), "g/cm**3")}
ds1 = load_uniform_grid(data,
ddims,
magnetic_unit=(sqrt4pi, "gauss"),
unit_system="cgs")
assert_allclose(ds1.magnetic_unit.value, sqrt4pi)
assert str(ds1.magnetic_unit.units) == "G"
mucu = ds1.magnetic_unit.to("code_magnetic")
assert_allclose(mucu.value, 1.0)
assert str(mucu.units) == "code_magnetic"
ds2 = load_uniform_grid(data,
ddims,
magnetic_unit=(1.0, "T"),
unit_system="cgs")
assert_allclose(ds2.magnetic_unit.value, 10000.0)
assert str(ds2.magnetic_unit.units) == "G"
mucu = ds2.magnetic_unit.to("code_magnetic")
assert_allclose(mucu.value, 1.0)
assert str(mucu.units) == "code_magnetic"
ds3 = load_uniform_grid(data,
ddims,
magnetic_unit=(1.0, "T"),
unit_system="mks")
assert_allclose(ds3.magnetic_unit.value, 1.0)
assert str(ds3.magnetic_unit.units) == "T"
mucu = ds3.magnetic_unit.to("code_magnetic")
assert_allclose(mucu.value, 1.0)
assert str(mucu.units) == "code_magnetic"
ds4 = load_uniform_grid(data,
ddims,
magnetic_unit=(1.0, "gauss"),
unit_system="mks")
assert_allclose(ds4.magnetic_unit.value, 1.0e-4)
assert str(ds4.magnetic_unit.units) == "T"
mucu = ds4.magnetic_unit.to("code_magnetic")
assert_allclose(mucu.value, 1.0)
assert str(mucu.units) == "code_magnetic"
def test_default_mu():
assert_allclose(default_mu, 0.5924489101195808)
def test_default_mu():
assert_allclose(compute_mu(None), 0.5924489101195808)
assert_allclose(compute_mu("ionized"), 0.5924489101195808)
assert_allclose(compute_mu("neutral"), 1.2285402715185552)
def test_tesla_magnetic_unit():
ytcfg["yt", "skip_dataset_cache"] = "True"
for us in ['cgs', 'mks', 'code']:
ds = load(wdm, unit_system=us,
units_override={'magnetic_unit': (1.0, 'T')})
ad = ds.all_data()
dens = ad['density']
magx = ad['magx']
magnetic_field_x = ad['magnetic_field_r']
if us == 'cgs':
assert str(dens.units) == 'g/cm**3'
assert str(magx.units) == 'code_magnetic'
assert magx.uq == ds.quan(1e4, 'G')
assert str(magnetic_field_x.units) == 'gauss'
assert_allclose(magx.value, magnetic_field_x.value/1e4)
assert_allclose(
magnetic_field_x.to_equivalent('T', 'SI').value,
magnetic_field_x.value/1e4)
if us == 'mks':
assert str(dens.units) == 'kg/m**3'
assert str(magx.units) == 'code_magnetic'
assert magx.uq == ds.quan(1, 'T')
assert str(magnetic_field_x.units) == 'T'
assert_allclose(magx.value, magnetic_field_x.value)
assert_allclose(magnetic_field_x.to_equivalent('G', 'CGS').value,
magnetic_field_x.value*1e4)
if us == 'code':
assert str(dens.units) == 'code_mass/code_length**3'
assert str(magx.units) == 'code_magnetic'
assert magx.uq == ds.quan(1, 'T')
assert str(magnetic_field_x.units) == 'code_magnetic'
assert_allclose(magx.value, magnetic_field_x.value)
assert_allclose(magnetic_field_x.to_equivalent('G', 'CGS').value,
magnetic_field_x.value*1e4)
