feat: NanoEvents Delphes

[kratsg]

This PR will aim to add functionality for coffea to read in Delphes files.

Docstrings are added for common names. The following were more complicated branches that needed to be handled / fixed in uproot first initially before being handled correctly in coffea. The schema is modified in a custom way to drop in the vector.LorentzVector behavior for those that are TLVs.

• Area (TLorentzVector)
• Constituents (TRefArray)
• Edges[4] (Float_t)
• FracPt[5] (Float_t)
• Particle (TRef)
• Particles (TRefArray)
• PrunedP4[5] (TLorentzVector)
• SoftDroppedJet (TLorentzVector)
• SoftDroppedP4[5] (TLorentzVector)
• SoftDroppedSubJet1 (TLorentzVector)
• SoftDroppedSubJet2 (TLorentzVector)
• Tau[5] (Float_t)
• TrimmedP4[5] (TLorentzVector)

We don't know why Area is a TLV.

[nsmith-]

With scikit-hep/uproot5#441 and scikit-hep/uproot5#442 I can now do:

import awkward as ak
from coffea.nanoevents import NanoEventsFactory, DelphesSchema

events = NanoEventsFactory.from_root(
    "tests/samples/delphes.root",
    "Delphes",
    schemaclass=DelphesSchema,
).events()
ak.to_list(events)

which confirms we can at least interpret all the branches successfully.

[kratsg]

Using

pip install -U git+git://github.com/scikit-hep/uproot4.git@007b10014003a74d0e89e0166e21a6218de0d445

and an editable install at the current commit baa2018, i have the following

>>> ak.type(data.Jet[0].Area)
2 * struct[["fE", "fP"], [float64, TVector3["fX": float64, "fY": float64, "fZ": float64]], parameters={"__doc__": "Area[Jet_]"}]
>>> data.Jet[0].Area
<Array [{fE: 0, fP: {fX: 0, ... fZ: 0}}] type='2 * struct[["fE", "fP"], [float64...'>

>>> ak.type(data.Jet[0]['PrunedP4[5]'])
2 * [5 * struct[["fE", "fP"], [float64, TVector3["fX": float64, "fY": float64, "fZ": float64]], parameters={"__doc__": "PrunedP4[Jet_]"}], parameters={"__doc__": "first entry (i = 0) is the total Pruned Jet 4-momenta and from i = 1 to 4 are the pruned subjets 4-momenta"}]
>>> data.Jet[0]['PrunedP4[5]']
<Array [[{fE: 0, fP: {fX: 0, ... fZ: 0}}]] type='2 * [5 * struct[["fE", "fP"], [...'>

and the others look ok

>>> data.Jet[0].SoftDroppedSubJet1
<Array [{fE: 111, fP: {, ... fZ: 17.5}}] type='2 * struct[["fE", "fP"], [float64...'>
>>> data.Jet[0]['TrimmedP4[5]']
<Array [[{fE: 0, fP: {fX: 0, ... fZ: 0}}]] type='2 * [5 * struct[["fE", "fP"], [...'>
>>> data.Jet[0]['PrunedP4[5]']
<Array [[{fE: 0, fP: {fX: 0, ... fZ: 0}}]] type='2 * [5 * struct[["fE", "fP"], [...'>
>>> data.Jet[0]['SoftDroppedP4[5]']
<Array [[{fE: 126, fP: {, ... fZ: 0}}]] type='2 * [5 * struct[["fE", "fP"], [flo...'>

So I want to add quicker access for some of the branches that have brackets in the name, and it would be nice to automatically interpret some of these as TLVs -- and that requires wrapping it somehow? Or is it expected that uproot or awkward is supposed to recognize it automatically? I thought Jim mentioned something about that.

[kratsg]

Can confirm it all looks ok without the TLV interpretations

>>> data.Jet.Area
<Array [[{fE: 0, fP: {fX: 0, ... fZ: 0}}]] type='25 * var * struct[["fE", "fP"],...'>
>>> data.Jet.Constituents
<Array [[{fName: '', fSize: 12, ... 5932]}]] type='25 * var * struct[["fName", "...'>
>>> data.Jet.Particles
<Array [[{fName: '', fSize: 12, ... 1929]}]] type='25 * var * struct[["fName", "...'>
>>> data.Jet.PrunedP4_5
<Array [[[{fE: 0, fP: {fX: 0, ... fZ: 0}}]]] type='25 * var * [5 * struct[["fE",...'>
>>> data.Jet.SoftDroppedJet
<Array [[{fE: 126, fP: {, ... fZ: 44.2}}]] type='25 * var * struct[["fE", "fP"],...'>
>>> data.Jet.SoftDroppedP4_5
<Array [[[{fE: 126, fP: {, ... fZ: 0}}]]] type='25 * var * [5 * struct[["fE", "f...'>
>>> data.Jet.SoftDroppedSubJet1
<Array [[{fE: 111, fP: {, ... fZ: 39.2}}]] type='25 * var * struct[["fE", "fP"],...'>
>>> data.Jet.SoftDroppedSubJet2
<Array [[{fE: 15.2, fP: {, ... fZ: 4.98}}]] type='25 * var * struct[["fE", "fP"]...'>
>>> data.Jet.Tau_5
<Array [[[0.197, 0.148, ... 0.0485, 0.0356]]] type='25 * var * [5 * float32[para...'>
>>> data.Jet.TrimmedP4_5
<Array [[[{fE: 0, fP: {fX: 0, ... fZ: 0}}]]] type='25 * var * [5 * struct[["fE",...'>

[nsmith-]

Certainly the vector interpretation of TLorentzVector directly via uproot will come in some form eventually, but anyway we'll also have to move coffea vectors to vector. For now I think it would make more sense to consistently use coffea vectors and when we move we can just adjust these as appropriate. To do that I think the easiest is to just define a mixin for the TLV that provides properties x y z t that then access the objects self["fP"]["fX"], ..., self["fE"]

[nsmith-]

Another option is to hack at the form to turn the record items into x y z t.

[kratsg]

Another option is to hack at the form to turn the record items into x y z t.

I went with this option for hacking at the form using a recursive function.

[nsmith-]

One last check I would suggest is make sure _ = ak.to_list(events) runs. This makes sure all arrays materialize successfully. The output will be gigantic so best not to print it :)