In [1]:

```
import yt
import numpy as np
```

In this example, we'll just create a 3-D array of random floating-point data using NumPy:

In [2]:

```
arr = np.random.random(size=(64,64,64))
```

`data`

dictionary consists of one or more fields, each consisting of a tuple of a NumPy array and a unit string. Then, we can call `load_uniform_grid`

:

In [3]:

```
data = dict(density = (arr, "g/cm**3"))
bbox = np.array([[-1.5, 1.5], [-1.5, 1.5], [-1.5, 1.5]])
ds = yt.load_uniform_grid(data, arr.shape, length_unit="Mpc", bbox=bbox, nprocs=64)
```

`load_uniform_grid`

takes the following arguments and optional keywords:

`data`

: This is a dict of numpy arrays, where the keys are the field names`domain_dimensions`

: The domain dimensions of the unigrid`length_unit`

: The unit that corresponds to`code_length`

, can be a string, tuple, or floating-point number`bbox`

: Size of computational domain in units of`code_length`

`nprocs`

: If greater than 1, will create this number of subarrays out of data`sim_time`

: The simulation time in seconds`mass_unit`

: The unit that corresponds to`code_mass`

, can be a string, tuple, or floating-point number`time_unit`

: The unit that corresponds to`code_time`

, can be a string, tuple, or floating-point number`velocity_unit`

: The unit that corresponds to`code_velocity`

`magnetic_unit`

: The unit that corresponds to`code_magnetic`

, i.e. the internal units used to represent magnetic field strengths.`periodicity`

: A tuple of booleans that determines whether the data will be treated as periodic along each axis

This example creates a yt-native dataset `ds`

that will treat your array as a
density field in cubic domain of 3 Mpc edge size and simultaneously divide the
domain into `nprocs`

= 64 chunks, so that you can take advantage
of the underlying parallelism.

The optional unit keyword arguments allow for the default units of the dataset to be set. They can be:

- A string, e.g.
`length_unit="Mpc"`

- A tuple, e.g.
`mass_unit=(1.0e14, "Msun")`

- A floating-point value, e.g.
`time_unit=3.1557e13`

In the latter case, the unit is assumed to be cgs.

The resulting `ds`

functions exactly like a dataset like any other yt can handle--it can be sliced, and we can show the grid boundaries:

In [4]:

```
slc = yt.SlicePlot(ds, "z", ["density"])
slc.set_cmap("density", "Blues")
slc.annotate_grids(cmap=None)
slc.show()
```

`number_of_particles`

key in
`data`

. Particle fields are then added as one-dimensional arrays in
a similar manner as the three-dimensional grid fields:

In [5]:

```
posx_arr = np.random.uniform(low=-1.5, high=1.5, size=10000)
posy_arr = np.random.uniform(low=-1.5, high=1.5, size=10000)
posz_arr = np.random.uniform(low=-1.5, high=1.5, size=10000)
data = dict(density = (np.random.random(size=(64,64,64)), "Msun/kpc**3"),
number_of_particles = 10000,
particle_position_x = (posx_arr, 'code_length'),
particle_position_y = (posy_arr, 'code_length'),
particle_position_z = (posz_arr, 'code_length'))
bbox = np.array([[-1.5, 1.5], [-1.5, 1.5], [-1.5, 1.5]])
ds = yt.load_uniform_grid(data, data["density"][0].shape, length_unit=(1.0, "Mpc"), mass_unit=(1.0,"Msun"),
bbox=bbox, nprocs=4)
```

`number_of_particles`

must be the same size as the particle
arrays. If no particle arrays are supplied then `number_of_particles`

is assumed to be zero. Take a slice, and overlay particle positions:

In [6]:

```
slc = yt.SlicePlot(ds, "z", ["density"])
slc.set_cmap("density", "Blues")
slc.annotate_particles(0.25, p_size=12.0, col="Red")
slc.show()
```

`load_uniform_grid`

to get it into yt:

In [7]:

```
import h5py
from yt.config import ytcfg
data_dir = ytcfg.get('yt','test_data_dir')
from yt.utilities.physical_ratios import cm_per_kpc
f = h5py.File(data_dir+"/UnigridData/turb_vels.h5", "r") # Read-only access to the file
```

The HDF5 file handle's keys correspond to the datasets stored in the file:

In [8]:

```
print (f.keys())
```

In [9]:

```
units = ["gauss","gauss","gauss", "g/cm**3", "erg/cm**3", "K",
"cm/s", "cm/s", "cm/s", "cm/s", "cm/s", "cm/s"]
```

In [10]:

```
data = {k:(v.value,u) for (k,v), u in zip(f.items(),units)}
bbox = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, 0.5]])
```

In [11]:

```
ds = yt.load_uniform_grid(data, data["Density"][0].shape, length_unit=250.*cm_per_kpc, bbox=bbox, nprocs=8,
periodicity=(False,False,False))
```

In [12]:

```
prj = yt.ProjectionPlot(ds, "z", ["z-velocity","Temperature","Bx"], weight_field="Density")
prj.set_log("z-velocity", False)
prj.set_log("Bx", False)
prj.show()
```