fill_none with empty array of specific Record type

[qibin2020]

Dear experts,
I want to ask how to use fill_none to fill a empty array of specific type. The example is like
I have one array of, say, 100*var*var*{px,py,pz}, and I want to pad/clip the second axis to 2, with pad_none(clip=True), it becomes
100*2*OptionType(ListType(RecordType(...),None)
Then I was wondering how to make it become
100*2*var*{px,py,pz} ? I have tried fill_none but not work, leaving still union or option type.

Is there any method I can do that?
(the final target I want to achieve is, e.g. with 100*2*var{px,py,pz}, I can easily take arr[:,1]["px"], to get the array of 100*var*float64 of each component and to be used later, without handling the optionType)
Thank you!
Q.

[jpivarski]

It becomes an option-type because it might need to insert None values to increase length-0 or length-1 lists to length-2.

>>> example = ak.Array([[[{"px": 1, "py": 2, "pz": 3}] * 2]] * 100)
>>> print(example.type)
100 * var * var * {px: int64, py: int64, pz: int64}

These lists are already length-2, but the type doesn't say that: the type is "var" (ragged). When you set target=2, it will increase any lists to reach length-2 by inserting None values, hence the option-type. The clip=2 just ensures that any lists longer than 2 will be clipped. (The axis=2 is the depth, which, in this case, is also coincidentally 2.)

>>> print(ak.pad_none(example, target=2, clip=2, axis=2).type)
100 * var * 2 * ?{px: int64, py: int64, pz: int64}

If you know that all of the lists in a ragged dimension happen to have the same length, you can use ak.to_regular instead of ak.pad_none.

>>> print(ak.to_regular(example, axis=2).type)
100 * var * 2 * {px: int64, py: int64, pz: int64}

If they aren't all the same length, you can use a slice to ensure that none are longer than 2:

>>> print(ak.to_regular(example[:, :, 0:2], axis=2).type)
100 * var * 2 * {px: int64, py: int64, pz: int64}

But if any are shorter than 2, you have to fill them with something. ak.pad_none is the only padding function, and it pads them with None. You can then change None to a different value with ak.fill_none.

>>> print(ak.fill_none(ak.pad_none(example, target=2, clip=2, axis=2), "hello", axis=2).type)
100 * var * 2 * union[{px: int64, py: int64, pz: int64}, string]

(The type is now a union of records and strings.)

>>> empty = ak.Record({"px": 0, "py": 0, "pz": 0})
>>> print(ak.fill_none(ak.pad_none(example, target=2, clip=2, axis=2), empty, axis=2).type)
100 * var * 2 * {px: int64, py: int64, pz: int64}

(The type is just records.)

[qibin2020]

Thank you! fill_none() is very helpful in this case by adding empty (with one zero record, but could be easily to identified later)
Just a further courious, is there some simple way make the empty array really "empty", e.g. like Array([]), but the type is identified as {px: int64, py: int64, pz: int64}?

[jpivarski]

A simple way is to take an array of that type and slice it with array[0:0].

>>> array = ak.Array([{"px": 1, "py": 2, "pz": 3}])
>>> array
<Array [{px: 1, py: 2, pz: 3}] type='1 * {px: int64, py: int64, pz: int64}'>
>>> array[0:0]
<Array [] type='0 * {px: int64, py: int64, pz: int64}'>