Cube arithmetic operations with scalars drop cell measures and ancillary variables

[schlunma]

🐛 Bug Report

Performing cube arithmetic operations with scalars drop cell measures and ancillary variables.

How To Reproduce

import iris
from iris.coords import CellMeasure, AncillaryVariable
from iris.cube import Cube


print("Iris version:", iris.__version__)
print()

cell_measure = CellMeasure(0.0)
ancillary_var = AncillaryVariable(0.0)
cube = Cube(
    0.0,
    cell_measures_and_dims=[(cell_measure, ())],
    ancillary_variables_and_dims=[(ancillary_var, ())],
)

print("before")
print(cube)

cube = 1.0 * cube

print()
print("after")
print(cube)

gives

Iris version: 3.14.1

before
unknown / (unknown)                 (scalar cube)
    Scalar cell measures:
        unknown
    Scalar ancillary variables:
        unknown

after
unknown / (unknown)                 (scalar cube)

Expected behaviour

Cell measures and ancillary variables should be unchanged.

Environment

• OS & Version: Linux
• Iris Version: 3.14.1

[bjlittle]

@schlunma Thanks for raising this issue, much appreciated!

This documentation on the finer details of cube arithmetic may be relevant.

I suspect that you'll see the same behaviour regardless of whether it's scalar or not?

[schlunma]

Thanks for your quick answer and the link @bjlittle! Sorry, I just looked at the section on Cube Maths before opening this issue. I understand now that this is rather a feature, not a bug.

You're totally right, the behavior is the same for non-scalar data. I made a mistake while testing it earlier and thought this is inconsistent between scalar and non-scalar arrays. This makes much more thanks now. Thanks!

[trexfeathers]

@schlunma when we discussed this yesterday we assumed this issue was a prompt to change the behaviour. Metadata handling is such a big topic that we deliberately didn't implement everything - we decided to wait for user feedback. Is the preservation of cell measures and ancillary variable something you would find valuable?

[schlunma]

Yes, I would find that very valuable (for scalars, but also for non-scalars). For cube-cube arithmetic it might require more thinking, but I think for cube-array or cube-coord operations it should be straightforward.