Vector of std::strings starts with

[DraTeots]

Actually, this relates to this question #229 and the same data as there - hits and tracks connected by ids

We have a data field which is a vector of std::strings.

tree['hit_vol_name'].interpretation

gives

AsObjects(AsVector(True, AsString(False)))

In reality each hit has a string with the volume name. Not very effective in terms of performance, but beyond this discussion. These strings looks like "ci_EMCAL_section1_tower22" and the naming is organized so that if one wants to get all hits in central-ion-cap EMCAL, he just need a filter like

hit_vol_name.startswith('ci_EMCAL')

I'm sure I could somehow flatten the data and those string would appear correctly in flattened arrays, where I could use numpy.char.startswith to select all hits from ci_EMCAL

But I'm wonder if one can do it inside iterate method without data flattening. Because as in #229 I would like to use this to get certain tracks:

for batch in tree.iterate(['hit_vol_name', 'hit_trk_id', 'trk_mom', 'trk_id'], step_size=5, entry_stop=10):
   # then I want all hits in ci_EMCAL, so I do something like
   good_tracks_id = batch.hit_trk_id[ak.char.startswith(batch.hit_vol_name, 'ci_EMCAL')]   # no such method!
   # now, having good_tracks_id I select tracks momentums as it resolved in #229

[jpivarski]

There isn't an ak.char.startswith (or any other ak.char.* functions), which would be vectorized versions of the ordinary string methods. The motivations for this would be

• convenience (it's a one-liner) and
• performance: in principle, such a function could be specialized, compiled C or C++. If an ak.char.* suite of functions is implemented like all the other Awkward functions, they'd also be part of the CPU → GPU port: all Awkward operations will eventually be CPU/GPU agnostic.

So that would be nice, and it could be a feature request for Awkward Array (probably not addressed in the next month or so, to be honest).

If you main concern is performance, note that your interpretation, AsObjects(AsVector(True, AsString(False))), cannot be vectorized, so it's interpreted with auto-generated Python code, rather than a NumPy cast. Before we get to nice touches like ak.char.startswith, I want to finish the job started with PR #96: moving that auto-generated Python code with a C++ state machine. In the first case that was tested, this was a factor of 80× speedup, and I expect that to be typical. (It's still non-vectorized, but that's less of a performance hit in C++ than in Python.) A blocker for this is #38: I need to understand memberwise splitting in Python before carving it into stone (porting to C++). So if your concern is performance, there are other hotspots that are higher priority before getting to vectorizing string functions.

If your concern is convenience, you might want to consider a list comprehension.

Wait a minute—(facepalm)—there's a nice implementation for vectorized startswith that you can do right now:

>>> strings = ak.Array([
...     ["ci_EMCAL-one", "ci_EMCAL-two", "something else"],
...     [],
...     ["yet another thing", "ci_EMCAL-three"]])

>>> print(strings[:, :, :len("ci_EMCAL")])
[['ci_EMCAL', 'ci_EMCAL', 'somethin'], [], ['yet anot', 'ci_EMCAL']]

>>> print(strings[:, :, :len("ci_EMCAL")] == "ci_EMCAL")
[[True, True, False], [], [False, True]]

There you go. :) Sorry for the digression.