# How to use the yt.units.yt_array.YTArray function in yt

## To help you get started, weâ€™ve selected a few yt examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

yt-project / unyt / tests / test_ytarray.py View on Github
a2 = array([4., 5., 6.])
a3 = [4, 5, 6]
answer1 = YTArray([0.25, 0.4, 0.5], 'cm')
answer2 = YTArray([4, 2.5, 2], '1/cm')

# Both dimensionless quantities
a1 = YTArray([1., 2., 3.])
a2 = array([4., 5., 6.])
a3 = [4, 5, 6]

operate_and_compare(a3, a1, np.divide, answer2)
yt-project / unyt / tests / test_ytarray.py View on Github
def test_ones_and_zeros_like():
data = YTArray([1, 2, 3], 'cm')
zd = np.zeros_like(data)
od = np.ones_like(data)

assert_equal(zd, YTArray([0, 0, 0], 'cm'))
assert_equal(zd.units, data.units)
assert_equal(od, YTArray([1, 1, 1], 'cm'))
assert_equal(od.units, data.units)
yt-project / unyt / tests / test_ytarray.py View on Github
def test_copy():
quan = YTQuantity(1, 'g')
arr = YTArray([1, 2, 3], 'cm')

assert_equal(copy.copy(quan), quan)
assert_array_equal(copy.copy(arr), arr)

assert_equal( copy.deepcopy(quan), quan)
assert_array_equal(copy.deepcopy(arr), arr)

assert_equal(quan.copy(), quan)
assert_array_equal(arr.copy(), arr)

assert_equal(np.copy(quan), quan)
assert_array_equal(np.copy(arr), arr)
yt-project / unyt / tests / test_ytarray.py View on Github
def test_ufuncs():
for ufunc in unary_operators:
if ufunc is None:
continue
unary_ufunc_comparison(ufunc, YTArray([.3, .4, .5], 'cm'))
unary_ufunc_comparison(ufunc, YTArray([12, 23, 47], 'g'))
unary_ufunc_comparison(ufunc, YTArray([2, 4, -6], 'erg/m**3'))

for ufunc in binary_operators:
if ufunc is None:
continue
# arr**arr is undefined for arrays with units because
# each element of the result would have different units.
if ufunc is np.power:
a = YTArray([.3, .4, .5], 'cm')
b = YTArray([.1, .2, .3], 'dimensionless')
c = np.array(b)
d = YTArray([1., 2., 3.], 'g')
binary_ufunc_comparison(ufunc, a, b)
binary_ufunc_comparison(ufunc, a, c)
assert_raises(YTUnitOperationError, ufunc, a, d)
continue

a = YTArray([.3, .4, .5], 'cm')
b = YTArray([.1, .2, .3], 'cm')
c = YTArray([.1, .2, .3], 'm')
d = YTArray([.1, .2, .3], 'g')
e = YTArray([.1, .2, .3], 'erg/m**3')

for pair in itertools.product([a, b, c, d, e], repeat=2):
binary_ufunc_comparison(ufunc, pair[0], pair[1])
yt-project / yt / yt / units / yt_array.py View on Github
for k, v in [(k, v) for k, v in lut.items() if len(v) == 2]:
lut[k] = v + (0.0, r'\rm{' + k.replace('_', '\ ') + '}')
self.units = Unit(unit, registry=registry)

def __deepcopy__(self, memodict=None):
"""copy.deepcopy implementation

This is necessary for stdlib deepcopy of arrays and quantities.
"""
if memodict is None:
memodict = {}
ret = super(YTArray, self).__deepcopy__(memodict)
return type(self)(ret, copy.deepcopy(self.units))

class YTQuantity(YTArray):
"""
A scalar associated with a unit.

Parameters
----------

input_scalar : an integer or floating point scalar
The scalar to attach units to
input_units : String unit specification, unit symbol object, or astropy units
The units of the quantity. Powers must be specified using python syntax
(cm**3, not cm^3).
registry : A UnitRegistry object
The registry to create units from. If input_units is already associated
with a unit registry and this is specified, this will be used instead of
the registry associated with the unit object.
dtype : data-type
yt-project / yt / yt / units / yt_array.py View on Github
def coerce_iterable_units(input_object):
if isinstance(input_object, np.ndarray):
return input_object
if iterable(input_object):
if any([isinstance(o, YTArray) for o in input_object]):
ff = getattr(input_object[0], 'units', NULL_UNIT, )
if any([ff != getattr(_, 'units', NULL_UNIT) for _ in input_object]):
raise YTIterableUnitCoercionError(input_object)
# This will create a copy of the data in the iterable.
return YTArray(input_object)
return input_object
else:
return input_object
yt-project / yt / yt / frontends / ytdata / utilities.py View on Github
The hdf5 file or group to which the data will be written.
field : str
The name of the field to be saved.
data : YTArray
The data array to be saved.

Returns
-------
dataset : hdf5 dataset
The created hdf5 dataset.

"""

dataset = fh.create_dataset(str(field), data=data)
units = ""
if isinstance(data, YTArray):
units = str(data.units)
dataset.attrs["units"] = units
return dataset

yt-project / yt / yt / analysis_modules / photon_simulator / spectral_models.py View on Github
mspec_l = np.zeros(self.nchan)
cspec_r = np.zeros(self.nchan)
mspec_r = np.zeros(self.nchan)
tindex = np.searchsorted(self.Tvals, kT)-1
if tindex &gt;= self.Tvals.shape[0]-1 or tindex &lt; 0:
return YTArray(cspec_l, "cm**3/s"), YTArray(mspec_l, "cm**3/s")
dT = (kT-self.Tvals[tindex])/self.dTvals[tindex]
# First do H,He, and trace elements
for elem in self.cosmic_elem:
cspec_l += self._make_spectrum(kT, elem, tindex+2)
cspec_r += self._make_spectrum(kT, elem, tindex+3)
# Next do the metals
for elem in self.metal_elem:
mspec_l += self._make_spectrum(kT, elem, tindex+2)
mspec_r += self._make_spectrum(kT, elem, tindex+3)
cosmic_spec = YTArray(cspec_l*(1.-dT)+cspec_r*dT, "cm**3/s")
metal_spec = YTArray(mspec_l*(1.-dT)+mspec_r*dT, "cm**3/s")
return cosmic_spec, metal_spec
yt-project / yt / yt / geometry / geometry_handler.py View on Github
def fwidth(self):
if self._fast_index is not None:
ci = self._fast_index.select_fwidth(
self.dobj.selector, self.data_size)
ci = YTArray(ci, input_units = "code_length",
registry = self.dobj.ds.unit_registry)
return ci
ci = np.empty((self.data_size, 3), dtype='float64')
ci = YTArray(ci, input_units = "code_length",
registry = self.dobj.ds.unit_registry)
if self.data_size == 0: return ci
ind = 0
for obj in self._fast_index or self.objs:
c = obj.select_fwidth(self.dobj)
if c.shape[0] == 0: continue
ci[ind:ind+c.shape[0], :] = c
ind += c.shape[0]
return ci
yt-project / yt / yt / utilities / parallel_tools / parallel_analysis_interface.py View on Github
recv = []
for i in range(send.shape[0]):
recv.append(self.alltoallv_array(send[i,:].copy(),
total_size, offsets, sizes))
recv = np.array(recv)
return recv
offset = offsets[self.comm.rank]
tmp_send = send.view(self.__tocast)
recv = np.empty(total_size, dtype=send.dtype)
if isinstance(send, YTArray):
# We assume send.units is consistent with the units
# on the receiving end.
if isinstance(send, ImageArray):
recv = ImageArray(recv, input_units=send.units)
else:
recv = YTArray(recv, send.units)
recv[offset:offset+send.size] = send[:]
dtr = send.dtype.itemsize / tmp_send.dtype.itemsize # > 1
roff = [off * dtr for off in offsets]
rsize = [siz * dtr for siz in sizes]
tmp_recv = recv.view(self.__tocast)
self.comm.Allgatherv((tmp_send, tmp_send.size, MPI.CHAR),
(tmp_recv, (rsize, roff), MPI.CHAR))
return recv

## yt

An analysis and visualization toolkit for volumetric data

BSD-3-Clause