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)