Arrays irregulares, desiguales, Awkward Arrays

¿Qué es Awkward Array?¶

La lección anterior incluía una rebanada complicada:

corte = muones["nMuon"] == 2

pt0 = muones["Muon_pt", corte, 0]

Las tres partes de la rebanada muones["Muon_pt", corte, 0]

1. seleccionan el campo "Muon_pt" de todos los registros del array,

2. aplican corte, un array booleano, para seleccionar solo los eventos con dos muones,

3. seleccionan el primer (0) muón de cada uno de esos pares. De manera similar para los segundos (1) muones.

NumPy no sería capaz de realizar una rebanada así, ni siquiera de representar un array de listas de longitud variable sin recurrir a arrays de objetos.

Awkward Array está diseñado para llenar este vacío:

A los arrays como este se les llama a veces “arrays irregulares” o “desiguales” (en inglés, “jagged arrays” o “ragged arrays”).

Rebanadas en Awkward Array¶

Las rebanadas básicas son una generalización de las de NumPy: lo que NumPy haría si tuviera listas de longitud variable.

Pregunta rápida: ¿por qué la última genera un error?

Las rebanadas con booleanos y con enteros también funcionan:

Igual que en NumPy, se pueden calcular arrays booleanos para las rebanadas, y funciones como ak.num son útiles para eso.

Ahora considera esto (similar a un ejemplo de la primera lección):

Este array, corte, no es solo un array de booleanos. Es un array irregular de booleanos. Todas sus listas anidadas encajan en las listas anidadas de array, por lo que puede seleccionar números en profundidad, en lugar de seleccionar listas.

Aplicación: seleccionar partículas, en lugar de eventos¶

Volviendo al TTree grande de la lección anterior,

Este array irregular de booleanos selecciona todos los muones con más de 20 GeV:

y este array de booleanos no irregular (hecho con ak.any) selecciona todos los eventos que tienen un muón con más de 20 GeV:

Pregunta rápida: construye exactamente el mismo corte_evento usando ak.max.

Pregunta rápida: aplica ambos cortes; es decir, selecciona los muones con más de 20 GeV de los eventos que los tienen.

Sugerencia: vas a querer construir un

depurados = muon_pt[corte_particula]

intermedio, y no puedes usar la variable corte_evento tal como está.

Sugerencia: el resultado final debería ser un array irregular, igual que muon_pt, pero con menos listas y menos elementos en esas listas.

depurados = muon_pt[corte_particula]
resultado_final = depurados[corte_evento]

Combinatoria en Awkward Array¶

Las listas de longitud variable presentan más problemas que solo el rebanado y el cálculo de fórmulas array por array. A menudo queremos combinar partículas en todos los pares posibles (dentro de cada evento) para buscar cadenas de desintegración.

Pares a partir de dos arrays, pares a partir de un solo array¶

Awkward Array tiene funciones que generan estas combinaciones. Por ejemplo, ak.cartesian toma un producto cartesiano por evento (cuando axis=1, el valor predeterminado).

Estos pares son 2-tuplas, que se parecen a registros en la forma en que se rebanan de un array: usando cadenas.

También existe ak.unzip, que extrae cada campo en un array separado (lo opuesto de ak.zip).

Ten en cuenta que estos izquierda y derecha no son los numeros y letras originales: han sido duplicados y tienen la misma forma.

El producto cartesiano es equivalente a este bucle for de C++ sobre dos colecciones:

for (int i = 0; i < numeros.size(); i++) {
  for (int j = 0; j < letras.size(); j++) {
    // calcular la fórmula con numeros[i] y letras[j]
  }
}

A veces, sin embargo, queremos encontrar todos los pares dentro de una sola colección, sin repetición. Eso sería equivalente a este bucle for de C++:

for (int i = 0; i < numeros.size(); i++) {
  for (int j = i + 1; j < numeros.size(); j++) {
    // calcular la fórmula con numeros[i] y numeros[j]
  }
}

La función de Awkward para este caso es ak.combinations.

Aplicación a los dimuones¶

La búsqueda de dimuones de la lección anterior fue un poco ingenua, en el sentido de que exigíamos que existieran exactamente dos muones en cada evento y solo calculábamos la masa de esa combinación. Si hubiera un tercer muón presente porque se trata de una desintegración electrodébil compleja o porque algo se midió mal, no veríamos los otros dos muones. Podrían ser dimuones reales.

Un mejor procedimiento sería buscar todos los pares de muones en un evento y aplicar algún criterio para seleccionarlos.

En este ejemplo, juntaremos con ak.zip las variables de los muones en registros.

La diferencia entre arrays y muones es que arrays contiene listas separadas de "Muon_pt", "Muon_eta", "Muon_phi", "Muon_charge", mientras que muones contiene listas de registros con los campos "pt", "eta", "phi", "charge".

Ahora podemos calcular pares de objetos muón

y separarlos en arrays del primer muón y del segundo muón de cada par.

Pregunta rápida: ¿cómo garantizarías que todas las listas de registros en mu1 y mu2 tengan las mismas longitudes? Sugerencia: consulta ak.num y ak.all.

Dado que sí tienen las mismas longitudes, podemos usarlos en una fórmula.

Pregunta rápida: ¿cuántas masas tenemos en cada evento? ¿Cómo se compara esto con muones, mu1 y mu2?

Graficar el array irregular¶

Dado que esta masa es un array irregular, no se puede histogramar directamente. Los histogramas toman un conjunto de números como entrada, pero este array contiene listas.

Suponiendo que solo quieres graficar los números de las listas, puedes usar ak.flatten para aplanar un nivel de listas, o ak.ravel para aplanar todos los niveles.

Alternativamente, supongamos que quieres graficar la masa candidata máxima de cada evento, sesgándola hacia los bosones Z. ak.max es una función diferente que selecciona un elemento de cada lista, cuando se usa con axis=1.

Algunos valores son None porque no hay máximo de una lista vacía. Llamar a ak.flatten con axis=0 elimina estos valores faltantes,

pero eliminar de entrada las listas vacías consigue lo mismo.

Ten en cuenta que aquí ak.ravel no es intercambiable con ak.flatten: aplana todos los niveles de anidamiento, pero conserva los valores faltantes, así que ak.ravel(ak.max(masa, axis=1)) todavía contiene None. Para eliminarlos, usa ak.drop_none. Vas a necesitar esto en el Ejercicio 3.