Feature request: What kind of quantity a unit represents

[sigvaldm]

Hi, it would be really cool if it was possible to get what kind of physical quantity a certain dimensionality represents, for instance if a unit is kg*m/s^2 you could get the string "force". For example:

F = ureg['N']
"{:what}".format(F.u) # returns "force"
# or
F.u.what() # returns ["force"]

I realize this is not trivial. It would require some sort of dictionary of combination of units, and mappings to what they are. Perhaps some combinations could be several things? In which case you would need to return a list. All possible combinations could of course not be covered, but one could cover relatively standard ones as a beginning: length, speed, acceleration, distance, force, temperature, magnetic flux density, and so forth.

[jondoesntgit]

I know WolframAlpha has this functionality example. For example, kg*m/s^2 can be force, weight, thrust, and tension.

I cas see uses for this in debugging. Sometimes pint spits out a long string of units, and it would be nice to see them more compactly represented.

[hgrecco]

This somehow similar to the discussion that came up when building to_compact and finding the most compact representation was too complex for general quantities.

But we can cover a limited, common cases building on what we have. This is partly covered by the dimensionality attribute in the quantity, but it returns everything in terms of base dimensions. For example:

>>> ureg('meter').dimensionality
<UnitsContainer({'[length]': 1.0})>
>>> ureg('are').dimensionality
<UnitsContainer({'[length]': 2.0})>

We could try to match this to other derived dimensionalities:

[area] = [length] ** 2

under a different attribute name. Once we have that, we could create a format specificer. What do you think?

[sigvaldm]

TL;DR: I like your suggestion @hgrecco.

Concerning the example from WolframAlpha where kg*m/s^2 can be both force, weight, thrust and tension: Weight is a kind of force, but a force is not necessarily a weight. The same goes for thrust and tension. I suppose everything that's measured in kg*m/s^2 must be a force, no? As far as I can imagine, Coulomb always measures charge, m/s always velocity and eV always energy (can you think of any counter-example?). Then I see two options, either 1) the attribute is the "always correct" string or 2) a list of compatible ones. I'm inclined towards the first option. If we opt for 1 but need 2, it will be discovered soon enough. If we opt for 2 but don't need it, we have introduced meaningless complexity, and it may never be reviewed again.

If we do go for option 2 I would still insist that there should be a "preferred" dimensionality (e.g. the first one). As far as I am concerned this is not just for debugging. It can also be used to automatically label things, but it would be unfortunate if some quantity is labeled as "tension" if it is in fact a thrust. Labeling it as a force wouldn't be too bad, though.

@hgrecco's suggestion of keeping .dimensionality as-is and making a new attribute for "force" etc. is reasonable. It's backwards-compatible and .dimensionality always works whereas the new one doesn't (in which case I think it should default to the same as .dimensionality).

[jondoesntgit]

There's going to be a lot of edge cases. For example, power [kg m^2 / s^2] has the same dimensionality as torque [kg m / s^2] * [m].

[jondoesntgit]

As an aside, a nice debugging feature (maybe it already exists): Suppose I have some quantity that's in terms of power Q_(1 ,'horsepower'). We do something akin to what isinstance does in standard python?

P = Q_(1, 'horsepower')
P.is('power')
# True
P.is('torque')
# True
P.is('distance')
# False

[jondoesntgit]

@sigvaldm

Are you thinking of using this to automatically label plots?

import matplotlib.pyplot as plt

t = np.arange(10) * u.s
d = np.arange(10) * 2 * u.m

plt.plot(t, d)

# automatically does the following
xlabel('time (s)')
ylabel('distance (m)')

[sigvaldm]

@jondoesntgit I believe you mean energy (not power), but yes, you are of course right. Perhaps it wouldn't be such a bad idea to have lists of compatible (non-base) units after all.

I am in fact thinking of automatically labeling plots, although it could be more general than that. It could also be lists of variables exported from python to LaTeX (or other formats). One might sometimes need to overrule this automatic labeling, of course, but it would be nice nevertheless. Anyway, what versions of Pint and Matplotlib are you using? I couldn't reproduce your example (I get nothing on the axes). I have Pint 0.8.1 and Matplotlib 2.2.2. Or are you perhaps suggesting this as a new feature to Pint? If that's the case I'm all for it :) I also think your .is() function is a good idea.

[jondoesntgit]

I was suggesting it as a new feature.

I use the most recent version of pint on all my environments, but have a smattering of Matplotlib versions.

Matplotlib already has some support for custom formatting of date information. I wonder if a cleaner solution would be to add some extra parameters to the ureg.setup_matplotlib function.

[andrewgsavage]

If Q_.is were added, we could use it in reverse in pint-pandas to work out what units we'd like to convert to.

So let's say I have a column "shaft torque", with base units kg·m²/s².
reverse_is(kg·m²/s²) = ["energy, "torque"]
Now we can look for energy and torque in the column name, which tells us we've got a torque so the units should be N m.

I've had a play with how it could work in Out[24] here https://github.com/andrewgsavage/pint-pandas/blob/infer_units/notebooks/Pandas_support.ipynb

Not a catch all, but would get most of my use cases!

[tdrford]

Automatically simplifying units may be difficult for reasons mentioned above but I think that a method that converted to the most applicable unit when called would be very useful. Here is what a function that I have been using (excuse the amateur coding)

preferred_units = ['m', 's', 'kg', 'm/s', 'W', 'N', 'J', 'm**2', 'L', 'V', 'A', 'dimensionless']
preferred_dict = dict([(ureg[x].dimensionality, x) for x in preferred_units])

def to_preferred(x):
    dim = x.dimensionality
    if dim in preferred_dict:
        return x.to(preferred_dict[dim]).to_compact()
    else:
        return x

This catches my use cases and allows me to easily find unexpected dimensions due to errors in formulas, etc.

Area = 5*ureg.mm * 1*ureg.m
print(Area)
Area = to_preferred(Area)
print(Area)

5 m·mm
5000.0 mm²

length = 10*ureg.m
diameter = 1*ureg.mm
rho = 7200 * ureg.kg / (ureg.m**3)
mass = rho * (ureg.pi / 4) * diameter**2 * length
print(mass)
mass = to_preferred(mass)
print(f"{mass:.4}")

18000.0 kg·mm²·π/m²
56.55 gram

[hgrecco]

I am closing this for the time being. Feel free to reopen.