def test_mag_factor(): ds1 = load(sloshing, units_override=uo_sloshing, magnetic_normalization="gaussian") assert ds1.magnetic_unit == np.sqrt(4.0 * np.pi * ds1.mass_unit / (ds1.time_unit**2 * ds1.length_unit)) sp1 = ds1.sphere("c", (100.0, "kpc")) pB1a = (sp1["athena", "cell_centered_B_x"]**2 + sp1["athena", "cell_centered_B_y"]**2 + sp1["athena", "cell_centered_B_z"]**2) / (8.0 * np.pi) pB1b = (sp1["gas", "magnetic_field_x"]**2 + sp1["gas", "magnetic_field_y"] **2 + sp1["gas", "magnetic_field_z"]**2) / (8.0 * np.pi) pB1a.convert_to_units("dyn/cm**2") pB1b.convert_to_units("dyn/cm**2") assert_allclose_units(pB1a, pB1b) assert_allclose_units(pB1a, sp1["magnetic_pressure"]) ds2 = load(sloshing, units_override=uo_sloshing, magnetic_normalization="lorentz_heaviside") assert ds2.magnetic_unit == np.sqrt(ds2.mass_unit / (ds2.time_unit**2 * ds2.length_unit)) sp2 = ds2.sphere("c", (100.0, "kpc")) pB2a = (sp2["athena", "cell_centered_B_x"]**2 + sp2["athena", "cell_centered_B_y"]**2 + sp2["athena", "cell_centered_B_z"]**2) / 2.0 pB2b = (sp2["gas", "magnetic_field_x"]**2 + sp2["gas", "magnetic_field_y"] **2 + sp2["gas", "magnetic_field_z"]**2) / 2.0 pB2a.convert_to_units("dyn/cm**2") pB2b.convert_to_units("dyn/cm**2") assert_allclose_units(pB2a, pB2b) assert_allclose_units(pB2a, sp2["magnetic_pressure"]) assert_allclose_units(pB1a, pB2a)
def test_rockstar(): from mpi4py import MPI tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) filename = os.path.join(os.path.dirname(__file__), "run_rockstar.py") comm = MPI.COMM_SELF.Spawn(sys.executable, args=[filename], maxprocs=3) comm.Disconnect() h1 = "rockstar_halos/halos_0.0.bin" d1 = load(h1) d1.parameters['format_revision'] = 2 for field in _fields: yield FieldValuesTest(d1, field, particle_type=True, decimals=1) h2 = "rockstar_halos/halos_1.0.bin" d2 = load(h2) d2.parameters['format_revision'] = 2 for field in _fields: yield FieldValuesTest(d2, field, particle_type=True, decimals=1) os.chdir(curdir) shutil.rmtree(tmpdir)
def test_nprocs(): ds1 = load(sloshing, units_override=uo_sloshing) sp1 = ds1.sphere("c", (100.0, "kpc")) prj1 = ds1.proj(("gas", "density"), 0) ds2 = load(sloshing, units_override=uo_sloshing, nprocs=8) sp2 = ds2.sphere("c", (100.0, "kpc")) prj2 = ds1.proj(("gas", "density"), 0) assert_equal( sp1.quantities.extrema(("gas", "pressure")), sp2.quantities.extrema(("gas", "pressure")), ) assert_allclose_units( sp1.quantities.total_quantity(("gas", "pressure")), sp2.quantities.total_quantity(("gas", "pressure")), ) for ax in "xyz": assert_equal( sp1.quantities.extrema(("gas", f"velocity_{ax}")), sp2.quantities.extrema(("gas", f"velocity_{ax}")), ) assert_allclose_units( sp1.quantities.bulk_velocity(), sp2.quantities.bulk_velocity() ) assert_equal(prj1[("gas", "density")], prj2[("gas", "density")])
def test_line_integral_convolution_callback(): with _cleanup_fname() as prefix: ds = fake_amr_ds( fields=("density", "velocity_x", "velocity_y", "velocity_z"), units=("g/cm**3", "cm/s", "cm/s", "cm/s"), ) for ax in "xyz": p = ProjectionPlot(ds, ax, "density") p.annotate_line_integral_convolution("velocity_x", "velocity_y") assert_fname(p.save(prefix)[0]) p = ProjectionPlot(ds, ax, "density", weight_field="density") p.annotate_line_integral_convolution("velocity_x", "velocity_y") assert_fname(p.save(prefix)[0]) p = SlicePlot(ds, ax, "density") p.annotate_line_integral_convolution("velocity_x", "velocity_y") assert_fname(p.save(prefix)[0]) # Now we'll check a few additional minor things p = SlicePlot(ds, "x", "density") p.annotate_line_integral_convolution( "velocity_x", "velocity_y", kernellen=100.0, lim=(0.4, 0.7), cmap=ytcfg.get("yt", "default_colormap"), alpha=0.9, const_alpha=True, ) p.save(prefix) with _cleanup_fname() as prefix: ds = load(cyl_2d) slc = SlicePlot(ds, "theta", "magnetic_field_strength") slc.annotate_line_integral_convolution("magnetic_field_r", "magnetic_field_z") assert_fname(slc.save(prefix)[0]) with _cleanup_fname() as prefix: ds = load(cyl_3d) slc = SlicePlot(ds, "r", "magnetic_field_strength") slc.annotate_line_integral_convolution("magnetic_field_theta", "magnetic_field_z") assert_fname(slc.save(prefix)[0]) slc = SlicePlot(ds, "z", "magnetic_field_strength") slc.annotate_line_integral_convolution("magnetic_field_cartesian_x", "magnetic_field_cartesian_y") assert_fname(slc.save(prefix)[0]) slc = SlicePlot(ds, "theta", "magnetic_field_strength") slc.annotate_line_integral_convolution("magnetic_field_r", "magnetic_field_z") assert_fname(slc.save(prefix)[0]) with _cleanup_fname() as prefix: ds = fake_amr_ds( fields=("density", "velocity_r", "velocity_theta", "velocity_phi"), units=("g/cm**3", "cm/s", "cm/s", "cm/s"), geometry="spherical", ) p = SlicePlot(ds, "r", "density") p.annotate_line_integral_convolution("velocity_theta", "velocity_phi") assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_nonspatial_data(): tmpdir = make_tempdir() curdir = os.getcwd() os.chdir(tmpdir) ds = data_dir_load(enzotiny) region = ds.box([0.25] * 3, [0.75] * 3) sphere = ds.sphere(ds.domain_center, (10, "Mpc")) my_data = {} my_data["region_density"] = region[("gas", "density")] my_data["sphere_density"] = sphere[("gas", "density")] fn = "test_data.h5" save_as_dataset(ds, fn, my_data) full_fn = os.path.join(tmpdir, fn) array_ds = load(full_fn) compare_unit_attributes(ds, array_ds) assert isinstance(array_ds, YTNonspatialDataset) yield YTDataFieldTest(full_fn, "region_density", geometric=False) yield YTDataFieldTest(full_fn, "sphere_density", geometric=False) my_data = {"density": YTArray(np.linspace(1.0, 20.0, 10), "g/cm**3")} fake_ds = {"current_time": YTQuantity(10, "Myr")} fn = "random_data.h5" save_as_dataset(fake_ds, fn, my_data) full_fn = os.path.join(tmpdir, fn) new_ds = load(full_fn) assert isinstance(new_ds, YTNonspatialDataset) yield YTDataFieldTest(full_fn, ("data", "density"), geometric=False) os.chdir(curdir) if tmpdir != ".": shutil.rmtree(tmpdir)
def test_nprocs(): ds1 = load(sloshing, units_override=uo_sloshing) sp1 = ds1.sphere("c", (100.0, "kpc")) prj1 = ds1.proj("density", 0) ds2 = load(sloshing, units_override=uo_sloshing, nprocs=8) sp2 = ds2.sphere("c", (100.0, "kpc")) prj2 = ds1.proj("density", 0) ds3 = load(sloshing, parameters=uo_sloshing) assert_equal(ds3.length_unit, 1.0 * u.Mpc) assert_equal(ds3.time_unit, 1.0 * u.Myr) assert_equal(ds3.mass_unit, 1e14 * u.Msun) assert_equal(sp1.quantities.extrema("pressure"), sp2.quantities.extrema("pressure")) assert_allclose_units( sp1.quantities.total_quantity("pressure"), sp2.quantities.total_quantity("pressure"), ) for ax in "xyz": assert_equal( sp1.quantities.extrema(f"velocity_{ax}"), sp2.quantities.extrema(f"velocity_{ax}"), ) assert_allclose_units(sp1.quantities.bulk_velocity(), sp2.quantities.bulk_velocity()) assert_equal(prj1["density"], prj2["density"])
def test_plot_data(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) ds = fake_random_ds(16) plot = SlicePlot(ds, "z", ("gas", "density")) fn = plot.data_source.save_as_dataset("slice.h5") ds_slice = load(fn) p = SlicePlot(ds_slice, "z", ("gas", "density")) fn = p.save() assert_fname(fn[0]) plot = ProjectionPlot(ds, "z", ("gas", "density")) fn = plot.data_source.save_as_dataset("proj.h5") ds_proj = load(fn) p = ProjectionPlot(ds_proj, "z", ("gas", "density")) fn = p.save() assert_fname(fn[0]) plot = SlicePlot(ds, [1, 1, 1], ("gas", "density")) fn = plot.data_source.save_as_dataset("oas.h5") ds_oas = load(fn) p = SlicePlot(ds_oas, [1, 1, 1], ("gas", "density")) fn = p.save() assert_fname(fn[0]) os.chdir(curdir) if tmpdir != ".": shutil.rmtree(tmpdir)
def test_velocity_callback(): with _cleanup_fname() as prefix: ds = fake_amr_ds( fields=("density", "velocity_x", "velocity_y", "velocity_z"), units=("g/cm**3", "cm/s", "cm/s", "cm/s"), ) for ax in "xyz": p = ProjectionPlot(ds, ax, ("gas", "density"), weight_field=("gas", "density")) p.annotate_velocity() assert_fname(p.save(prefix)[0]) p = SlicePlot(ds, ax, ("gas", "density")) p.annotate_velocity() assert_fname(p.save(prefix)[0]) # Test for OffAxis Slice p = SlicePlot(ds, [1, 1, 0], ("gas", "density"), north_vector=[0, 0, 1]) p.annotate_velocity(factor=40, normalize=True) assert_fname(p.save(prefix)[0]) # Now we'll check a few additional minor things p = SlicePlot(ds, "x", ("gas", "density")) p.annotate_velocity(factor=8, scale=0.5, scale_units="inches", normalize=True) assert_fname(p.save(prefix)[0]) with _cleanup_fname() as prefix: ds = fake_hexahedral_ds(fields=[f"velocity_{ax}" for ax in "xyz"]) sl = SlicePlot(ds, 1, ("connect1", "test")) sl.annotate_velocity() assert_fname(sl.save(prefix)[0]) with _cleanup_fname() as prefix: ds = load(cyl_2d) slc = SlicePlot(ds, "theta", ("gas", "velocity_magnitude")) slc.annotate_velocity() assert_fname(slc.save(prefix)[0]) with _cleanup_fname() as prefix: ds = load(cyl_3d) for ax in ["r", "z", "theta"]: slc = SlicePlot(ds, ax, ("gas", "velocity_magnitude")) slc.annotate_velocity() assert_fname(slc.save(prefix)[0]) slc = ProjectionPlot(ds, ax, ("gas", "velocity_magnitude")) slc.annotate_velocity() assert_fname(slc.save(prefix)[0]) with _cleanup_fname() as prefix: ds = fake_amr_ds( fields=("density", "velocity_r", "velocity_theta", "velocity_phi"), units=("g/cm**3", "cm/s", "cm/s", "cm/s"), geometry="spherical", ) p = ProjectionPlot(ds, "r", ("gas", "density")) p.annotate_velocity(factor=40, normalize=True) assert_raises(YTDataTypeUnsupported, p.save, prefix)
def test_profile_data(): tmpdir = make_tempdir() curdir = os.getcwd() os.chdir(tmpdir) ds = data_dir_load(enzotiny) ad = ds.all_data() profile_1d = create_profile(ad, "density", "temperature", weight_field="cell_mass") fn = profile_1d.save_as_dataset() full_fn = os.path.join(tmpdir, fn) prof_1d_ds = load(full_fn) compare_unit_attributes(ds, prof_1d_ds) assert isinstance(prof_1d_ds, YTProfileDataset) for field in profile_1d.standard_deviation: assert_array_equal( profile_1d.standard_deviation[field], prof_1d_ds.profile.standard_deviation["data", field[1]], ) p1 = ProfilePlot(prof_1d_ds.data, "density", "temperature", weight_field="cell_mass") p1.save() yield YTDataFieldTest(full_fn, "temperature", geometric=False) yield YTDataFieldTest(full_fn, "x", geometric=False) yield YTDataFieldTest(full_fn, "density", geometric=False) profile_2d = create_profile( ad, ["density", "temperature"], "cell_mass", weight_field=None, n_bins=(128, 128), ) fn = profile_2d.save_as_dataset() full_fn = os.path.join(tmpdir, fn) prof_2d_ds = load(full_fn) compare_unit_attributes(ds, prof_2d_ds) assert isinstance(prof_2d_ds, YTProfileDataset) p2 = PhasePlot(prof_2d_ds.data, "density", "temperature", "cell_mass", weight_field=None) p2.save() yield YTDataFieldTest(full_fn, "density", geometric=False) yield YTDataFieldTest(full_fn, "x", geometric=False) yield YTDataFieldTest(full_fn, "temperature", geometric=False) yield YTDataFieldTest(full_fn, "y", geometric=False) yield YTDataFieldTest(full_fn, "cell_mass", geometric=False) os.chdir(curdir) if tmpdir != ".": shutil.rmtree(tmpdir)
def test_magnetic_callback(): with _cleanup_fname() as prefix: ds = fake_amr_ds( fields=( "density", "magnetic_field_x", "magnetic_field_y", "magnetic_field_z", ) ) for ax in "xyz": p = ProjectionPlot(ds, ax, "density", weight_field="density") p.annotate_magnetic_field() assert_fname(p.save(prefix)[0]) p = SlicePlot(ds, ax, "density") p.annotate_magnetic_field() assert_fname(p.save(prefix)[0]) # Test for OffAxis Slice p = SlicePlot(ds, [1, 1, 0], "density", north_vector=[0, 0, 1]) p.annotate_magnetic_field(factor=40, normalize=True) assert_fname(p.save(prefix)[0]) # Now we'll check a few additional minor things p = SlicePlot(ds, "x", "density") p.annotate_magnetic_field( factor=8, scale=0.5, scale_units="inches", normalize=True ) assert_fname(p.save(prefix)[0]) with _cleanup_fname() as prefix: ds = load(cyl_2d) slc = SlicePlot(ds, "theta", "magnetic_field_strength") slc.annotate_magnetic_field() assert_fname(slc.save(prefix)[0]) with _cleanup_fname() as prefix: ds = load(cyl_3d) for ax in ["r", "z", "theta"]: slc = SlicePlot(ds, ax, "magnetic_field_strength") slc.annotate_magnetic_field() assert_fname(slc.save(prefix)[0]) slc = ProjectionPlot(ds, ax, "magnetic_field_strength") slc.annotate_magnetic_field() assert_fname(slc.save(prefix)[0]) with _cleanup_fname() as prefix: ds = fake_amr_ds( fields=( "density", "magnetic_field_r", "magnetic_field_theta", "magnetic_field_phi", ), geometry="spherical", ) p = ProjectionPlot(ds, "r", "density") p.annotate_magnetic_field( factor=8, scale=0.5, scale_units="inches", normalize=True ) assert_raises(YTDataTypeUnsupported, p.save, prefix)
def _fix_ds(arg, *args, **kwargs): if os.path.isdir(f"{arg}") and os.path.exists(f"{arg}/{arg}"): ds = load(f"{arg}/{arg}", *args, **kwargs) elif os.path.isdir(f"{arg}.dir") and os.path.exists(f"{arg}.dir/{arg}"): ds = load(f"{arg}.dir/{arg}", *args, **kwargs) elif arg.endswith(".index"): ds = load(arg[:-10], *args, **kwargs) else: ds = load(arg, *args, **kwargs) return ds
def _load(self, output_fn, **kwargs): from yt.loaders import load if self._dataset_cls is not None: return self._dataset_cls(output_fn, **kwargs) elif self._mixed_dataset_types: return load(output_fn, **kwargs) ds = load(output_fn, **kwargs) self._dataset_cls = ds.__class__ return ds
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_load_ambiguous_data(tmp_path): with pytest.raises(YTAmbiguousDataType): load(tmp_path) file = tmp_path / "fake_datafile0011.dump" file.touch() pattern = str(tmp_path / "fake_datafile00??.dump") # loading a DatasetSeries should not crash until an item is retrieved ts = load(pattern) with pytest.raises(YTAmbiguousDataType): ts[0]
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_halo_finders(self): from mpi4py import MPI filename = os.path.join(os.path.dirname(__file__), "run_halo_finder_ts.py") for method in methods: comm = MPI.COMM_SELF.Spawn( sys.executable, args=[filename, method, self.tmpdir], maxprocs=methods[method], ) comm.Disconnect() if method == "rockstar": hcfns = [f"halos_{i}.0.bin" for i in range(2)] else: hcfns = [ os.path.join(f"DD{i:04d}", f"DD{i:04d}.0.h5") for i in [20, 46] ] for hcfn in hcfns: fn = os.path.join(self.tmpdir, "halo_catalogs", method, hcfn) ds = load(fn) if method == "rockstar": ds.parameters["format_revision"] = 2 ds_type = RockstarDataset else: ds_type = YTHaloCatalogDataset assert isinstance(ds, ds_type)
def test_region_chunked_read(): # see #2104 ds = load("IsolatedGalaxy/galaxy0030/galaxy0030") sp = ds.sphere((0.5, 0.5, 0.5), (2, "kpc")) dense_sp = sp.cut_region(['obj["H_p0_number_density"]>= 1e-2']) dense_sp.quantities.angular_momentum_vector()
def test_halo_analysis_finders(): from mpi4py import MPI curdir = os.getcwd() filename = os.path.join(os.path.dirname(__file__), "run_halo_finder.py") for method in methods: tmpdir = tempfile.mkdtemp() os.chdir(tmpdir) comm = MPI.COMM_SELF.Spawn(sys.executable, args=[filename, method, tmpdir], maxprocs=methods[method]) comm.Disconnect() fn = os.path.join(tmpdir, "halo_catalogs", method, "%s.0.h5" % method) ds = load(fn) if method == "rockstar": ds.parameters['format_revision'] = 2 assert isinstance(ds, YTHaloCatalogDataset) for field in _fields: yield FieldValuesTest(ds, field, particle_type=True, decimals=decimals[method]) os.chdir(curdir) shutil.rmtree(tmpdir)
def test_set_units(): ds = load(tgal) sp = ds.sphere("max", (1.0, "Mpc")) pp = ParticlePhasePlot(sp, ("Gas", "density"), ("Gas", "temperature"), ("Gas", "particle_mass")) # make sure we can set the units using the tuple without erroring out pp.set_unit(("Gas", "particle_mass"), "Msun")
def run(self): curdir = os.getcwd() tmpdir = tempfile.mkdtemp() os.chdir(tmpdir) dds = data_dir_load(self.data_ds_fn) hds = data_dir_load(self.halos_ds_fn) hc = HaloCatalog(data_ds=dds, halos_ds=hds, output_dir=os.path.join(tmpdir, str(dds))) hc.add_callback("sphere") hc.add_quantity("nstars") hc.create() fn = os.path.join(tmpdir, str(dds), "%s.0.h5" % str(dds)) ds = load(fn) ad = ds.all_data() mi, ma = ad.quantities.extrema("nstars") mean = ad.quantities.weighted_average_quantity("nstars", "particle_ones") os.chdir(curdir) shutil.rmtree(tmpdir) return np.array([mean, mi, ma])
def _check_for_outputs(self, potential_outputs): r""" Check a list of files to see if they are valid datasets. """ only_on_root(mylog.info, "Checking %d potential outputs.", len(potential_outputs)) my_outputs = {} for my_storage, output in parallel_objects(potential_outputs, storage=my_outputs): try: ds = load(output) except (FileNotFoundError, YTUnidentifiedDataType): mylog.error("Failed to load %s", output) continue my_storage.result = { "filename": output, "time": ds.current_time.in_units("s"), } if ds.cosmological_simulation: my_storage.result["redshift"] = ds.current_redshift my_outputs = [ my_output for my_output in my_outputs.values() if my_output is not None ] return my_outputs
def test_groupBased_out(): dss = load(groupBased) particle_types = ("all", "io", "nbody") field_list = list(product(particle_types, particle_fields)) field_list += [ ("openPMD", "J_x"), ("openPMD", "J_y"), ("openPMD", "J_z"), ("openPMD", "e-chargeDensity"), ] domain_dimensions = [32, 64, 64] * np.ones_like(dss[0].domain_dimensions) domain_width = [0.0002752, 0.0005504, 0.0005504] * np.ones_like( dss[0].domain_left_edge) assert_equal(len(dss), 101) for i in range(0, len(dss), 20): # Test only every 20th ds out of the series ds = dss[i] assert_equal(str(ds), "simData.h5") assert_equal(ds.dimensionality, 3) assert_equal(ds.particle_types_raw, ("io", )) assert_array_equal(ds.field_list, field_list) assert_array_equal(ds.domain_dimensions, domain_dimensions) assert ds.current_time >= np.zeros_like(ds.current_time) assert ds.current_time <= 1.6499999999999998e-12 * np.ones_like( ds.current_time) assert_almost_equal(ds.domain_right_edge - ds.domain_left_edge, domain_width)
def test_cell_edges_callback(): with _cleanup_fname() as prefix: ds = fake_amr_ds(fields=("density",)) for ax in "xyz": p = ProjectionPlot(ds, ax, "density") p.annotate_cell_edges() assert_fname(p.save(prefix)[0]) p = ProjectionPlot(ds, ax, "density", weight_field="density") p.annotate_cell_edges() assert_fname(p.save(prefix)[0]) p = SlicePlot(ds, ax, "density") p.annotate_cell_edges() assert_fname(p.save(prefix)[0]) # Now we'll check a few additional minor things p = SlicePlot(ds, "x", "density") p.annotate_cell_edges(alpha=0.7, line_width=0.9, color=(0.0, 1.0, 1.0)) p.save(prefix) with _cleanup_fname() as prefix: ds = load(cyl_2d) slc = SlicePlot(ds, "theta", "density") slc.annotate_cell_edges() assert_fname(slc.save(prefix)[0]) with _cleanup_fname() as prefix: ds = fake_amr_ds(fields=("density",), geometry="spherical") p = SlicePlot(ds, "r", "density") p.annotate_cell_edges() assert_raises(YTDataTypeUnsupported, p.save, prefix)
def _check_for_outputs(self, potential_outputs): r""" Check a list of files to see if they are valid datasets. """ only_on_root(mylog.info, "Checking %d potential outputs.", len(potential_outputs)) my_outputs = {} llevel = mylog.level # suppress logging as we load every dataset, unless set to debug if llevel > 10 and llevel < 40: mylog.setLevel(40) for my_storage, output in parallel_objects(potential_outputs, storage=my_outputs): if os.path.exists(output): try: ds = load(output) if ds is not None: my_storage.result = { "filename": output, "time": ds.current_time.in_units("s") } if ds.cosmological_simulation: my_storage.result["redshift"] = ds.current_redshift except YTOutputNotIdentified: mylog.error("Failed to load %s", output) mylog.setLevel(llevel) my_outputs = [my_output for my_output in my_outputs.values() \ if my_output is not None] return my_outputs
def test_absorption_spectrum_non_cosmo_sph(self): """ This test generates an absorption spectrum from a simple light ray on a particle dataset """ ds = load(GIZMO_PLUS_SINGLE) lr = LightRay(ds) ray_start = ds.domain_left_edge ray_end = ds.domain_right_edge lr.make_light_ray(start_position=ray_start, end_position=ray_end, fields=[('gas', 'temperature'), ('gas', 'H_p0_number_density')], data_filename='lightray.h5') sp = AbsorptionSpectrum(1200.0, 1300.0, 10001) my_label = 'HI Lya' field = ('gas', 'H_p0_number_density') wavelength = 1215.6700 # Angstromss f_value = 4.164E-01 gamma = 6.265e+08 mass = 1.00794 sp.add_line(my_label, field, wavelength, f_value, gamma, mass, label_threshold=1.e10) filename = "spectrum.h5" wavelength, flux = sp.make_spectrum('lightray.h5', output_file=filename, output_absorbers_file='lines.txt', use_peculiar_velocity=True) return filename
def test_grid_datacontainer_data(): tmpdir = make_tempdir() curdir = os.getcwd() os.chdir(tmpdir) ds = data_dir_load(enzotiny) cg = ds.covering_grid(level=0, left_edge=[0.25] * 3, dims=[16] * 3) fn = cg.save_as_dataset(fields=[ ("gas", "density"), ("all", "particle_mass"), ("all", "particle_position"), ]) full_fn = os.path.join(tmpdir, fn) cg_ds = load(full_fn) compare_unit_attributes(ds, cg_ds) assert isinstance(cg_ds, YTGridDataset) assert ( cg["all", "particle_position"].shape == cg_ds.r["all", "particle_position"].shape) yield YTDataFieldTest(full_fn, ("grid", "density")) yield YTDataFieldTest(full_fn, ("all", "particle_mass")) ag = ds.arbitrary_grid(left_edge=[0.25] * 3, right_edge=[0.75] * 3, dims=[16] * 3) fn = ag.save_as_dataset(fields=[("gas", "density"), ("all", "particle_mass")]) full_fn = os.path.join(tmpdir, fn) ag_ds = load(full_fn) compare_unit_attributes(ds, ag_ds) assert isinstance(ag_ds, YTGridDataset) yield YTDataFieldTest(full_fn, ("grid", "density")) yield YTDataFieldTest(full_fn, ("all", "particle_mass")) my_proj = ds.proj(("gas", "density"), "x", weight_field=("gas", "density")) frb = my_proj.to_frb(1.0, (800, 800)) fn = frb.save_as_dataset(fields=[("gas", "density")]) frb_ds = load(fn) assert_array_equal(frb[("gas", "density")], frb_ds.data[("gas", "density")]) compare_unit_attributes(ds, frb_ds) assert isinstance(frb_ds, YTGridDataset) yield YTDataFieldTest(full_fn, ("grid", "density"), geometric=False) os.chdir(curdir) if tmpdir != ".": shutil.rmtree(tmpdir)
def can_run_ds(ds_fn, file_check=False): r""" Validates whether or not a given input can be loaded and used as a Dataset object. """ if isinstance(ds_fn, Dataset): return True path = ytcfg.get("yt", "test_data_dir") if not os.path.isdir(path): return False if file_check: return os.path.isfile(os.path.join(path, ds_fn)) try: load(ds_fn) return True except FileNotFoundError: return False
def test_load_ambiguous_data_with_hint(hint, expected_type, tmp_path): ds = load(tmp_path, hint=hint) assert type(ds).__name__ == expected_type file1 = tmp_path / "fake_datafile0011.dump" file2 = tmp_path / "fake_datafile0022.dump" file1.touch() file2.touch() pattern = str(tmp_path / "fake_datafile00??.dump") ts = load(pattern, hint=hint) ds = ts[0] assert type(ds).__name__ == expected_type ds = ts[1] assert type(ds).__name__ == expected_type
def test_default_to_cartesian(): data = {"density": np.random.random(128)} ds_attrs = {"current_time": YTQuantity(10, "Myr")} with TemporaryDirectory() as tmpdir: tmpf = os.path.join(tmpdir, "savefile.h5") fn = save_as_dataset(ds_attrs, tmpf, data) ds2 = load(fn) assert ds2.geometry == "cartesian"
def can_run_ds(ds_fn, file_check=False): result_storage = AnswerTestingTest.result_storage if isinstance(ds_fn, Dataset): return result_storage is not None path = ytcfg.get("yt", "test_data_dir") if not os.path.isdir(path): return False if file_check: return os.path.isfile(os.path.join(path, ds_fn)) and result_storage is not None try: load(ds_fn) except FileNotFoundError: if ytcfg.get("yt", "internals", "strict_requires"): if result_storage is not None: result_storage["tainted"] = True raise return False return result_storage is not None