"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"events.Muon[ak.num(events.Muon)>0].matched_jet.pt.compute()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For generated particles, the parent index is similarly mapped:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"[[None, None, 1, 1, 23, 23, 23, 23, ..., 15, -15, -15, -15, -15, -15, 111, 111],\n",
" [None, None, -1, 23, 23, 23, 23, ..., -11, None, None, None, None, None, 433],\n",
" [None, None, -1, -1, 23, 23, 23, 23, ..., -423, -1, -1, -421, -421, 111, 111],\n",
" [None, None, 21, 21, 23, -1, 23, 23, ..., -15, -15, -15, -15, -15, 111, 111],\n",
" [None, None, 21, 21, 23, 23, 23, 23, ..., 13, 13, -13, 1, None, None, 2, 2],\n",
" [None, None, 4, 23, 23, 23, 23, 23, ..., -15, -15, -15, 15, 15, 15, 423, 311],\n",
" [None, None, 2, 2, 2, 23, 23, 2, 23, ..., -13, 13, 2, 2, 2, 2, 111, 111, 111],\n",
" [None, None, -2, -2, 23, 21, 21, 23, 23, ..., 21, 21, 21, 21, None, 423, 2, 2],\n",
" [None, None, 2, 23, 23, 23, 23, 23, ..., -15, -15, -15, -15, 111, 111, 311],\n",
" [None, None, 1, 1, 1, 23, 21, 23, 23, 23, ..., -411, 21, 21, 1, 1, 1, 1, 3, 3],\n",
" ...,\n",
" [None, None, 1, 23, 23, 23, 23, 23, ..., -15, -15, -15, -15, 1, 1, 111, 111],\n",
" [None, None, -2, 23, 23, 23, 23, 23, 13, 13, -13, -13, -13, 13],\n",
" [None, None, 2, 2, 2, 23, 2, 23, ..., None, -413, 413, 413, 2, 2, -421, -421],\n",
" [None, None, 1, 23, 23, 23, 23, 23, ..., -15, 15, 15, 15, -15, -15, -15, -15],\n",
" [None, None, 2, 2, 23, 23, 21, 23, ..., 15, 15, 15, -15, -15, -15, 111, 111],\n",
" [None, None, -2, 23, 23, None, 23, 23, ..., -15, -15, -15, 423, 4, 4, 3, 3],\n",
" [None, None, -1, 23, 23, 23],\n",
" [None, None, 2, 23, 23, 23, 23, -11, -11, 11],\n",
" [None, None, 1, 1, 23, 23, 23, 23, ..., -15, -15, -15, 111, 111, 111, 111]]\n",
"--------------------------------------------------------------------------------\n",
"type: 40 * var * ?int32[parameters={"__doc__": "PDG id"}]"
],
"text/plain": [
""
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"events.GenPart.parent.pdgId.compute()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In addition, using the parent index, a helper method computes the inverse mapping, namely, `children`. As such, one can find particle siblings with:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"[[None, None, [23, 21], ..., [-16, 111, ..., 211, -211], [22, 22], [22, 22]],\n",
" [None, None, [23], [23], [23], [23], ..., None, None, None, None, None, [431]],\n",
" [None, None, [23, -1], [23, -1], [23], ..., [13, -14], [13, -14], [22], [22]],\n",
" [None, None, [23, -1], ..., [-16, 111, ..., 211, -211], [22, 22], [22, 22]],\n",
" [None, None, [23, 1], [23, 1], [23], ..., None, None, [11, -11], [11, -11]],\n",
" [None, None, [23], [23], ..., [16, 13, -14], [16, 13, -14], [421], [310]],\n",
" [None, None, [23, 2, 2], [23, 2, 2], ..., [...], [22], [11, -11], [11, -11]],\n",
" [None, None, [23, 21], [23, 21], [23], ..., None, [421], [11, -11], [11, -11]],\n",
" [None, None, [23], [23], ..., [-16, 111, ..., 311], [22, 22], [22, 22], [310]],\n",
" [None, None, [23, 21, 21], [23, ...], ..., [11, -11], [11, -11], [11, -11]],\n",
" ...,\n",
" [None, None, [23], [23], [23], ..., [11, -11], [11, -11], [22, 22], [22, 22]],\n",
" [None, None, [23], [23], [23], ..., [...], [-13], [-13, 22], [-13, 22], [13]],\n",
" [None, None, [23, 2, 21], ..., [2, 21, ..., 11, -11], [13, -14], [13, -14]],\n",
" [None, None, [23], ..., [...], [-16, 211, 211, -211], [-16, 211, 211, -211]],\n",
" [None, None, [23, 21], [23, 21], ..., [-16, -11, 12], [22, 22], [22, 22]],\n",
" [None, None, [23], [23], ..., [423, -421, 11, -11], [11, -11], [11, -11]],\n",
" [None, None, [23], [23], [-13, 13], [-13, 13]],\n",
" [None, None, [23], [23], [23], ..., [-11, 11], [-11, 22], [-11, 22], [11]],\n",
" [None, None, [23, 21], [23, 21], ..., [22, ...], [22, 22], [22, 22], [22, 22]]]\n",
"--------------------------------------------------------------------------------\n",
"type: 40 * var * option[var * ?int32[parameters={"__doc__": "PDG id"}]]"
],
"text/plain": [
""
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"events.GenPart.parent.children.pdgId.compute()\n",
"# notice this is a doubly-jagged array"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Since often one wants to shortcut repeated particles in a decay sequence, a helper method `distinctParent` is also available. Here we use it to find the parent particle ID for all prompt electrons:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"[[],\n",
" [23, 23],\n",
" [23, 23],\n",
" [],\n",
" [],\n",
" [],\n",
" [],\n",
" [23, 23],\n",
" [],\n",
" [23, 23],\n",
" ...,\n",
" [],\n",
" [],\n",
" [23, 23],\n",
" [],\n",
" [],\n",
" [],\n",
" [],\n",
" [23, 23],\n",
" []]\n",
"---------------------------------------------------------\n",
"type: 40 * var * ?int32[parameters={"__doc__": "PDG id"}]"
],
"text/plain": [
""
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"events.GenPart[\n",
" (abs(events.GenPart.pdgId) == 11)\n",
" & events.GenPart.hasFlags(['isPrompt', 'isLastCopy'])\n",
"].distinctParent.pdgId.compute()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Events can be filtered like any other awkward array using boolean fancy-indexing"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"[94.6,\n",
" 87.6,\n",
" 88,\n",
" 90.4,\n",
" 89.1,\n",
" 31.6]\n",
"-----------------\n",
"type: 6 * float32"
],
"text/plain": [
""
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mmevents = events[ak.num(events.Muon) == 2]\n",
"zmm = mmevents.Muon[:, 0] + mmevents.Muon[:, 1]\n",
"zmm.mass.compute()"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"[94.6,\n",
" 87.6,\n",
" 88,\n",
" 90.4,\n",
" 89.1,\n",
" 31.6]\n",
"-----------------\n",
"type: 6 * float32"
],
"text/plain": [
""
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# a convenience method is available to sum vectors along an axis:\n",
"mmevents.Muon.sum(axis=1).mass.compute()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As expected for this sample, most of the dimuon events have a pair invariant mass close to that of a Z boson. But what about the last event? Let's take a look at the generator information:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[-13, 13]\n",
"[False, False]\n"
]
}
],
"source": [
"print(mmevents[-1].Muon.matched_gen.pdgId.compute())\n",
"print(mmevents[-1].Muon.matched_gen.hasFlags([\"isPrompt\"]).compute())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So they are real generated muons, but they are not prompt (i.e. from the initial decay of a heavy resonance)\n",
"\n",
"Let's look at their parent particles:"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"[-15,\n",
" 15]\n",
"--------------------------------------------------\n",
"type: 2 * ?int32[parameters={"__doc__": "PDG id"}]"
],
"text/plain": [
""
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mmevents[-1].Muon.matched_gen.parent.pdgId.compute()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"aha! They are muons coming from tau lepton decays, and hence a fair amount of the Z mass is carried away by the neutrinos:"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"31.265245\n",
"91.68365\n"
]
}
],
"source": [
"print(mmevents[-1].Muon.matched_gen.sum().mass.compute())\n",
"print(mmevents[-1].Muon.matched_gen.parent.sum().mass.compute())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One can assign new variables to the arrays, with some caveats:\n",
"\n",
" * Assignment must use setitem (`events[\"path\", \"to\", \"name\"] = value`)\n",
" * Assignment to a sliced `events` won't be accessible from the original variable\n",
" * New variables are not visible from cross-references"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"[[],\n",
" [121],\n",
" [],\n",
" [],\n",
" [],\n",
" []]\n",
"-----------------------\n",
"type: 6 * var * float32"
],
"text/plain": [
""
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mmevents[\"Electron\", \"myvariable\"] = mmevents.Electron.pt + zmm.mass\n",
"mmevents.Electron.myvariable.compute()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}