From 4ef7c7e86f0a0e1ceaa152bf13dc09bb0a8e98f0 Mon Sep 17 00:00:00 2001 From: Angela White <123964490+AWh1t3@users.noreply.github.com> Date: Fri, 19 May 2023 13:00:28 -0500 Subject: [PATCH 1/3] 2x2 Light larndsim Tutorial-2.ipynb --- examples/2x2 Light larndsim Tutorial-2.ipynb | 1116 ++++++++++++++++++ 1 file changed, 1116 insertions(+) create mode 100644 examples/2x2 Light larndsim Tutorial-2.ipynb diff --git a/examples/2x2 Light larndsim Tutorial-2.ipynb b/examples/2x2 Light larndsim Tutorial-2.ipynb new file mode 100644 index 00000000..a0735e36 --- /dev/null +++ b/examples/2x2 Light larndsim Tutorial-2.ipynb @@ -0,0 +1,1116 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "56dab8ca", + "metadata": {}, + "source": [ + "# larnd_sim Light Simulations: \n", + "\n", + "## Before starting:\n", + "### This tutorial aims to familiarize users with the structure of light simulation output from larnd_sim. It uses files from MiniRun3, located [here](https://portal.nersc.gov/project/dune/data/2x2/simulation/productions/MiniRun3_1E19_RHC/MiniRun3_1E19_RHC.larnd_v2/LARNDSIM/). \n", + "### Please download the first file, titled MiniRun3_1E19_RHC.larnd_v2.00000.LARNDSIM.h5 (1.3G) to replicate the plots in this tutorial.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "994ba732", + "metadata": {}, + "outputs": [], + "source": [ + "## STANDARD IMPORTS\n", + "import uproot, h5py\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "## 3D PLOTTING\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import mpl_toolkits.mplot3d.art3d as art3d\n", + "import matplotlib.gridspec as gridspec\n", + "from matplotlib import cm, colors\n", + "import matplotlib.patches as mpatches" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4d6ac8ef", + "metadata": {}, + "outputs": [], + "source": [ + "## LOAD THE SIMULATION FILE\n", + "\n", + "fname = 'MiniRun3_1E19_RHC.larnd_v2.00000.LARNDSIM.h5'\n", + "h5 = h5py.File(fname,'r')" + ] + }, + { + "cell_type": "markdown", + "id": "3f959f06", + "metadata": {}, + "source": [ + "## First, we look at the available branches:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c7ab345a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "-------------------File Contents--------------------\n", + "File Name: MiniRun3_1E19_RHC.larnd_v2.00000.LARNDSIM.h5\n", + "\n", + "Available branches: ['_header', 'configs', 'genie_hdr', 'genie_stack', 'light_dat', 'light_trig', 'light_wvfm', 'mc_packets_assn', 'messages', 'packets', 'tracks', 'trajectories', 'vertices']\n", + "\n", + "\n" + ] + } + ], + "source": [ + "## INSPECT FILE STRUCTURE\n", + "\n", + "print('\\n-------------------File Contents--------------------')\n", + "print('File Name: '+str(fname)+'\\n')\n", + "print(f'Available branches: {[t for t in h5.keys()]}')\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "689ea7af", + "metadata": {}, + "source": [ + "## _header and configs store file ID information and constants used in the simulation:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "adae5ebe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stored Values in _header:\n", + "\n", + " created: 1683335720.7198143 \n", + "\n", + " modified: 1683336130.2974105 \n", + "\n", + " version: 2.4 \n", + "\n", + "Stored Values in configs:\n", + "\n", + " drift_length: 30.27225 \n", + "\n", + " lifetime: 2200.0 \n", + "\n", + " long_diff: 4e-06 \n", + "\n", + " pixel_layout: larnd-sim/larndsim/pixel_layouts/multi_tile_layout-2.3.16.yaml \n", + "\n", + " tran_diff: 8.8e-06 \n", + "\n", + " vdrift: 0.1596452482154287 \n", + "\n", + "Available keys in configs: ['timestamp', 'io_group', 'io_channel', 'chip_id', 'registers']\n", + "\n", + "\n" + ] + } + ], + "source": [ + "header = h5['_header']\n", + "print(f'Stored Values in _header:\\n')\n", + "for key, val in header.attrs.items():\n", + " print(f' %s: %s \\n' % (key, val))\n", + " \n", + "configs = h5['configs']\n", + "print(f'Stored Values in configs:\\n')\n", + "for key, val in configs.attrs.items():\n", + " print(f' %s: %s \\n' % (key, val))\n", + " \n", + "print(f'Available keys in configs: {[t for t in configs.dtype.names]}')\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "4fdd0eea", + "metadata": {}, + "source": [ + "## Two branches provide GENIE backtracking:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1d787f8d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available keys in genie_hdr: ['eventID', 'vertexID', 'vertex', 'target', 'isCC', 'isQES', 'isMEC', 'isRES', 'isDIS', 'isCOH', 'Enu', 'nu_4mom', 'nu_pdg', 'Elep', 'lep_mom', 'lep_ang', 'lep_pdg', 'q0', 'q3', 'Q2', 'x', 'y']\n", + "\n", + "\n", + "Available keys in genie_stack: ['eventID', 'vertexID', 'trackID', 'part_4mom', 'part_pdg', 'part_status']\n", + "\n", + "\n" + ] + } + ], + "source": [ + "genie_hdr = h5['genie_hdr']\n", + "print(f'Available keys in genie_hdr: {[t for t in genie_hdr.dtype.names]}')\n", + "print('\\n')\n", + "\n", + "genie_stack = h5['genie_stack']\n", + "print(f'Available keys in genie_stack: {[t for t in genie_stack.dtype.names]}')\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "8d61f061", + "metadata": {}, + "source": [ + "## Six branches provide charge output, but I focus on three:\n", + "\n", + "### mc_packets_assn: \n", + " This branch contains truth information linking the packets branch to the tracks branch.\n", + "### packets: \n", + " This is the dataset that most resembles actual charge data (i.e., it contains the least truth information).\n", + "### tracks: \n", + " This dataset is necesarry for track reconstruction and backtracking." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b71862ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available keys in mc_packets_assn: ['track_ids', 'fraction']\n", + "\n", + "\n", + "Available keys in messages: ['message', 'timestamp', 'index']\n", + "\n", + "\n", + "Available keys in packets: ['io_group', 'io_channel', 'chip_id', 'packet_type', 'downstream_marker', 'parity', 'valid_parity', 'channel_id', 'timestamp', 'dataword', 'trigger_type', 'local_fifo', 'shared_fifo', 'register_address', 'register_data', 'direction', 'local_fifo_events', 'shared_fifo_events', 'counter', 'fifo_diagnostics_enabled', 'first_packet', 'receipt_timestamp']\n", + "\n", + "\n", + "Available keys in tracks: ['eventID', 'vertexID', 'segment_id', 'z_end', 'trackID', 'tran_diff', 'z_start', 'x_end', 'y_end', 'n_electrons', 'pdgId', 'x_start', 'y_start', 't_start', 't0_start', 't0_end', 't0', 'dx', 'long_diff', 'pixel_plane', 't_end', 'dEdx', 'dE', 't', 'y', 'x', 'z', 'n_photons']\n", + "\n", + "\n", + "Available keys in trajectories: ['eventID', 'vertexID', 'trackID', 'local_trackID', 'parentID', 'E_start', 'pxyz_start', 'xyz_start', 't_start', 'E_end', 'pxyz_end', 'xyz_end', 't_end', 'pdgId', 'start_process', 'start_subprocess', 'end_process', 'end_subprocess']\n", + "\n", + "\n", + "Available keys in vertices: ['eventID', 'vertexID', 'x_vert', 'y_vert', 'z_vert', 't_vert', 't_event']\n", + "\n", + "\n" + ] + } + ], + "source": [ + "mc_assn = h5['mc_packets_assn']\n", + "print(f'Available keys in mc_packets_assn: {[t for t in mc_assn.dtype.names]}')\n", + "print('\\n')\n", + "\n", + "messages = h5['messages']\n", + "print(f'Available keys in messages: {[t for t in messages.dtype.names]}')\n", + "print('\\n')\n", + "\n", + "packets = h5['packets']\n", + "print(f'Available keys in packets: {[t for t in packets.dtype.names]}')\n", + "print('\\n')\n", + "\n", + "tracks = h5['tracks']\n", + "print(f'Available keys in tracks: {[t for t in tracks.dtype.names]}')\n", + "print('\\n')\n", + "\n", + "traject = h5['trajectories']\n", + "print(f'Available keys in trajectories: {[t for t in traject.dtype.names]}')\n", + "print('\\n')\n", + "\n", + "vertices = h5['vertices']\n", + "print(f'Available keys in vertices: {[t for t in vertices.dtype.names]}')\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "ab63f58f", + "metadata": {}, + "source": [ + "## Three branches provide light simulation output: \n", + "\n", + "### light_dat:\n", + " This contains truth information.\n", + "### light_trig:\n", + " This lists the optical channel triggered and provides two timestamps. \n", + " ts_sync in this dataset and timestamp in packets can be used to group SiPM and charge pixel triggers into combined events.\n", + "### light_wvfm:\n", + " This dataset contains the simulated light waveforms for each triggered SiPM (optical channel). Each waveform consists of 1000 samples, 0.01 μs apart. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2997571b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Available keys in light_dat: ['segment_id', 'n_photons_det', 't0_det']\n", + "\n", + "\n", + "Available keys in light_trig: ['op_channel', 'ts_s', 'ts_sync']\n", + "\n", + "\n", + "Stored Values in light_wvfm:\n", + "\n", + "Available keys in light_wvfm: NONE, it is a single nested dataset\n", + "\n", + "\n" + ] + } + ], + "source": [ + "light_dat = h5['light_dat']\n", + "print(f'Available keys in light_dat: {[t for t in light_dat.dtype.names]}')\n", + "print('\\n')\n", + "\n", + "light_trig = h5['light_trig']\n", + "print(f'Available keys in light_trig: {[t for t in light_trig.dtype.names]}')\n", + "print('\\n')\n", + "\n", + "light_wvfm = h5['light_wvfm']\n", + "print(f'Stored Values in light_wvfm:\\n')\n", + "for key, val in light_wvfm.attrs.items():\n", + " print(f' %s: %s \\n' % (key, val))\n", + "\n", + "print(f'Available keys in light_wvfm: NONE, it is a single nested dataset')\n", + "print('\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "49a59022", + "metadata": {}, + "source": [ + "## Defining Common Values:\n", + "\n", + "### Spill Period: \n", + " The simulation does not currently include cosmics, so light and charge are triggered by the simulated\n", + " neutrino beam spills. Spills occur every 1.2e7 ticks, where 1 tick = 0.01 μs.\n", + "### Samples:\n", + " Each waveform in MiniRun3 is comprised of 1000 samples, but the simulation is still in development. For\n", + " now, it's better to define constants in general terms.\n", + "### Bit: \n", + " As in the the real module data output, light output can utilize up to 16 bits. The sampling time\n", + " determined how many bits are actually used. All unutilized bits are set to one. \n", + " \n", + " If the data requires 14 bits, the last two bits are set to 1. Thus, the smallest possible value that \n", + " can be sampled by the light simulation becomes (0^14)*(2^2) = 4, rather than (0^16) = 1. \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5722dead", + "metadata": {}, + "outputs": [], + "source": [ + "## DEFINE COMMON VALUES\n", + "\n", + "SPILL_PERIOD = 1.2e7\n", + "\n", + "SAMPLES = len(light_wvfm[0][0])\n", + "\n", + "BIT = min(x for x in abs(light_wvfm[0][0]) if x != 0)" + ] + }, + { + "cell_type": "markdown", + "id": "6a3abff8", + "metadata": {}, + "source": [ + "## Load relevant datasets:\n", + "\n", + "### packet_type: \n", + " This dataset tags packet entries by trigger type. 0 = charge trigger. 7 = light trigger. I exclude entries\n", + " with trigger types other than 0 or 7, because they can make mapping light to charge through timestamps \n", + " more difficult. \n", + "### eventD and trackID:\n", + " These datasets are necessary for reconstructing charge tracks in the detector volume. They can be linked to\n", + " packets using mc_truth_assn. EventID can be artificially linked to the light simulation using ts_sync\n", + " (currently, events are spills).\n", + "### op_channel:\n", + " Each SiPM in the detector is assigned a value out of 384. This dataset maps waveforms to the detector's geometry. \n", + "### io_group: \n", + " Each module has 2 TPCs, and each is assigned an io_group value. \n", + "### io_channel: \n", + " Pixel channels within each io_group." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a87a5230", + "metadata": {}, + "outputs": [], + "source": [ + "## LOAD NECESSARY DATASETS\n", + "\n", + "pack_type = np.array(packets['packet_type'])\n", + "p_tstamp = np.array(packets['timestamp'])\n", + "l_tsync = np.array(light_trig['ts_sync'])\n", + "spillID = np.array(tracks['eventID'])\n", + "trackID = np.array(tracks['trackID'])\n", + "opt_chan = np.array(light_trig['op_channel'])\n", + "io_group = np.array(packets['io_group'])\n", + "io_channel = np.array(packets['io_channel'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1a363d48", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 956 light events\n", + "\n", + "Packet Type\n", + "of Charge Trigger:\n", + "------------------\n", + "trig.| \n", + "type |count\n", + "-----------\n", + "0 149242\n", + "4 3368\n", + "7 1786\n", + "6 248\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "## INSPECT PACKET TYPES\n", + "\n", + "print('There are '+str(len(l_tsync))+' light events\\n')\n", + " \n", + "df = pd.DataFrame(pack_type)\n", + "df1 = df.value_counts()\n", + "print('Packet Type\\nof Charge Trigger:')\n", + "print('------------------')\n", + "print('trig.| \\ntype |count')\n", + "print('-----------')\n", + "print(df1)" + ] + }, + { + "cell_type": "markdown", + "id": "4ee44da1", + "metadata": {}, + "source": [ + "## Timestamp Turnover: \n", + " To link light and charge, we divide ts_sync by the spill period. In a simulation without cosmics to trigger\n", + " the detector outside of spills, this always works. \n", + " \n", + " However, charge timestamps for packets only go up to 2136000190 (2^31 ticks), which is 179 spills\n", + " counting from 0). These files contain more than 179 events. This must be accounted for when assigning the\n", + " packet and light branches eventIDs." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4a1cf74e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "195\n", + "178.95697058333334\n", + "178.00001583333332\n" + ] + } + ], + "source": [ + "## SEE THAT TIMESTAMP TURNOVER MUST BE ACCOUNTED FOR \n", + "## WHEN LINKING DATA-LIKE AND TRUTH-LIKE BRANCHES\n", + "\n", + "print(max(spillID))\n", + "print(max(p_tstamp)/SPILL_PERIOD)\n", + "print(max(l_tsync)/SPILL_PERIOD)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b4886c01", + "metadata": {}, + "outputs": [], + "source": [ + "## PACKET TYPES 4 AND 6 CAN MESS UP THIS CORRECTION, SO EXCLUDE THEM\n", + "\n", + "tstamp_trig0 = p_tstamp[pack_type==0]\n", + "tstamp_trig7 = p_tstamp[pack_type==7]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a98ff9c8", + "metadata": {}, + "outputs": [], + "source": [ + "## IDENTIFY THE INDEX WHERE THE TURNOVER OCCURS\n", + "\n", + "charge_cutoff = np.where(tstamp_trig0 > 1.999**31)[0][-1]\n", + "light_cutoff = np.where(tstamp_trig7 > 1.999**31)[0][-1]\n", + "wvfm_cutoff = np.where(l_tsync > 1.999**31)[0][-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "18b9a4cf", + "metadata": {}, + "outputs": [], + "source": [ + "## ADD 2^31 TO ALL TIMESTAMPS FOLLOWING THE TURNOVER\n", + "\n", + "tstamp_real_trig0 = np.concatenate((tstamp_trig0[:(charge_cutoff+1)],((2**31)+tstamp_trig0[(charge_cutoff+1):])))\n", + "tstamp_real_trig7 = np.concatenate((tstamp_trig7[:(light_cutoff+1)],((2**31)+tstamp_trig7[(light_cutoff+1):])))\n", + "l_tsync_real = np.concatenate((l_tsync[:(wvfm_cutoff+1)],((2**31)+l_tsync[(wvfm_cutoff+1):])))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c560186f", + "metadata": {}, + "outputs": [], + "source": [ + "## DEFINE SPILLID (EVENTID) FOR PACKETS AND LIGHT\n", + "\n", + "light_spillIDs = (np.rint(l_tsync_real/SPILL_PERIOD)).astype(int)\n", + "packet0_spillIDs = (np.rint(tstamp_real_trig0/SPILL_PERIOD)).astype(int)\n", + "packet7_spillIDs = (np.rint(tstamp_real_trig7/SPILL_PERIOD)).astype(int)\n", + "\n", + "list_spillIDs = np.unique(light_spillIDs)" + ] + }, + { + "cell_type": "markdown", + "id": "11a8f569", + "metadata": {}, + "source": [ + "## Check:\n", + " Plotting eventID vs. their index in the dataset is a good check to make sure this works:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "974b9230", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(18,6))\n", + "\n", + "indices = np.arange(0,len(p_tstamp),1)\n", + "indices_0 = indices[pack_type==0]\n", + "indices_7 = indices[pack_type==7]\n", + "\n", + "plt.plot(tstamp_real_trig0,indices_0, \"o\", color='dodgerblue', label='larpix')\n", + "plt.plot(tstamp_real_trig7,indices_7,\".\", color='tomato', label='light')\n", + "plt.axvline(x=(2**31), label='LArPix Clock Rollover')\n", + "\n", + "plt.title('Larpix (Spill) Trigger vs. Light Trigger\\n', fontsize=18)\n", + "plt.xlabel(r'Timestamp [0.01$\\mu$s]', fontsize=14)\n", + "plt.ylabel('Packet Index', fontsize=16)\n", + "#plt.xlim(175, 195)\n", + "plt.legend(fontsize=16)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c934401c", + "metadata": {}, + "source": [ + "## Inspecting Light Readout\n", + " For every light simulation trigger, there should be two Pacman triggers of packet_type = 7. Also, an event\n", + " triggering light readout in one TPC should trigger readout in the entire module. Thus, every event/spill \n", + " should have 8 light triggers and 16 packet_type = 7 triggers. Expect to see these features change in later\n", + " runs. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "85339670", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "## TRIGGERS IN LIGHT AND CHARGE PER SPILL\n", + "\n", + "fig = plt.figure(figsize=(14,6))\n", + "\n", + "bins = np.linspace(min(packet7_spillIDs),max(packet7_spillIDs),392)\n", + "bin_width = bins[2] - bins[1]\n", + "\n", + "counts, bins = np.histogram(np.array(light_spillIDs), bins=bins)\n", + "plt.hist(bins[:-1], bins, weights=counts, color='tomato', label='Light: '+str(len(l_tsync))+' triggers')\n", + "\n", + "counts, bins = np.histogram(np.array(packet7_spillIDs), bins=bins)\n", + "plt.hist(bins[:-1], bins, weights=counts, histtype=\"step\", color='dodgerblue', label='Pacman: '+str(len(packet7_spillIDs))+' triggers')\n", + "\n", + "plt.title('Triggers Per Spill ('+str(len(list_spillIDs))+' Spills)\\n', fontsize=16)\n", + "plt.xlabel('Spill', fontsize=14)\n", + "plt.ylabel('Triggers', fontsize=14)\n", + "plt.ylim(0,max(counts)+2)\n", + "plt.xlim(0,40)\n", + "plt.grid(axis='y', color='0.85')\n", + "plt.legend(loc='upper left', fontsize=14)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d9b84c39", + "metadata": {}, + "source": [ + "## Looking at Waveforms:\n", + "### light_wvfm: \n", + " The light_wvfm dataset has 3 axes: \n", + " 1. axis = 0 gives the number of light triggers\n", + " 2. axis = 1 each trigger is a module, with 96 optical channels (SiPMs)\n", + " 3. axis = 2 each channel outputs a waveform made from 1000 samples\n", + " \n", + "### geometry: \n", + " Modules in the simulation are numbered 1-4 (not 0-3) and their waveforms can be identified using the first\n", + " optical channel in the associated op_channel dataset.\n", + " \n", + " Mod.1 channels = 0-95\n", + " Mod.2 channels = 96-191\n", + " Mod.3 channels = 192-287\n", + " Mod.4 channels = 288-383\n", + " \n", + " Becuase not every module triggers for every event (for now), this needs to be checked case-by-case" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "06304229", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(956, 96, 1000)\n", + "opt_chan[0][0] = 0: Ergo, light_wvfm[0] is readout from Module 1\n" + ] + } + ], + "source": [ + "## CHECK SHAPE AND MODULE\n", + "\n", + "print(np.shape(light_wvfm))\n", + "print('opt_chan[0][0] = '+str(opt_chan[0][0])+': Ergo, light_wvfm[0] is readout from Module 1')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9be613b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "## PLOT SINGLE WAVEFORM\n", + "\n", + "fig = plt.figure(figsize=(10,4))\n", + "plt.plot(np.linspace(0,SAMPLES-1,SAMPLES),light_wvfm[0][0]/BIT, label='Opt. Chan. 0')\n", + "plt.title('Module 1, Event '+str(light_spillIDs[0])+', Optical Channel 1', fontsize=16)\n", + "plt.xlabel(r'Time Sample [0.01 $\\mu$s]', fontsize=14)\n", + "plt.ylabel('SiPM Channel Output', fontsize=14)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "6187259b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "## A PEAK\n", + "\n", + "fig = plt.figure(figsize=(10,4))\n", + "plt.plot(np.linspace(0,SAMPLES-1,SAMPLES),light_wvfm[19][0]/BIT, label='Opt. Chan. 0')\n", + "plt.title('Module 3, Timestamp '+str(light_spillIDs[19])+', Optical Channel 196', fontsize=16)\n", + "plt.xlabel(r'Time Sample [0.01 $\\mu$s]', fontsize=14)\n", + "plt.ylabel('SiPM Channel Output', fontsize=14)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d0362d89", + "metadata": {}, + "source": [ + "## Visualizing Light Alongside Charge\n", + " If you're looking at a light simulation, odds are you're going to want to compare it to charge, or at least\n", + " use light and charge positioning as a sanity check. This is computationally expensive (because of charge \n", + " backtracking), and I usually only run it for one spill at a time." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "47ea39cf", + "metadata": {}, + "outputs": [], + "source": [ + "## SELECT A SPILL TO INSPECT\n", + "\n", + "SPILL = 8" + ] + }, + { + "cell_type": "markdown", + "id": "7cd8c1c1", + "metadata": {}, + "source": [ + "### \"Sum Channels\":\n", + " To simplify the visual, I generally create \"sum channels\". In the modules, each Arclight or each set of 3\n", + " adjacent LCMs form a sum channel of 6 SiPMs. I mimic that. \n", + " \n", + "### left and right:\n", + " In this code, \"left\" and \"right\" are determined relative to the TPC drift direction. Note that the geometry\n", + " is mirrored for TPCs in the same module. " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c9d2db36", + "metadata": {}, + "outputs": [], + "source": [ + "## ASSIGN \"SUM CHANNEL\" POSITIONS (this would be one side of one TPC)\n", + "\n", + "SiPM_struct = np.array([0,0,0,0,0,0,\n", + " 1,1,1,1,1,1,\n", + " 2,2,2,2,2,2,\n", + " 3,3,3,3,3,3])\n", + "\n", + "## SELECT DATASETS BELONGING TO YOUR SPILL\n", + "\n", + "spill_light = np.where(light_spillIDs == SPILL)[0]\n", + "\n", + "## CREATE EMPTY DATASETS FOR EACH LIGHT ARRAY (one side of one TPC)\n", + "\n", + "l_mod1_1L = np.zeros((24,SAMPLES))\n", + "l_mod1_1R = np.zeros((24,SAMPLES))\n", + "l_mod1_2L = np.zeros((24,SAMPLES))\n", + "l_mod1_2R = np.zeros((24,SAMPLES))\n", + "\n", + "l_mod2_3L = np.zeros((24,SAMPLES))\n", + "l_mod2_3R = np.zeros((24,SAMPLES))\n", + "l_mod2_4L = np.zeros((24,SAMPLES))\n", + "l_mod2_4R = np.zeros((24,SAMPLES)) \n", + "\n", + "l_mod3_5L = np.zeros((24,SAMPLES))\n", + "l_mod3_5R = np.zeros((24,SAMPLES))\n", + "l_mod3_6L = np.zeros((24,SAMPLES))\n", + "l_mod3_6R = np.zeros((24,SAMPLES))\n", + "\n", + "l_mod4_7L = np.zeros((24,SAMPLES))\n", + "l_mod4_7R = np.zeros((24,SAMPLES))\n", + "l_mod4_8L = np.zeros((24,SAMPLES))\n", + "l_mod4_8R = np.zeros((24,SAMPLES)) \n", + "\n", + "## SORT THE LIGHT DATA BY MODULE, TPC, and SIDE\n", + "\n", + "for j in spill_light:\n", + "\n", + " if (opt_chan[j][0]) == 0: \n", + " l_mod1_1L = np.add(l_mod1_1L,light_wvfm[j][0:24])\n", + " l_mod1_1R = np.add(l_mod1_1R,light_wvfm[j][24:48])\n", + " l_mod1_2R = np.add(l_mod1_2R,light_wvfm[j][48:72])\n", + " l_mod1_2L = np.add(l_mod1_2L,light_wvfm[j][72:96])\n", + "\n", + " if opt_chan[j][0]==96:\n", + " l_mod2_3L = np.add(l_mod2_3L,light_wvfm[j][0:24])\n", + " l_mod2_3R = np.add(l_mod2_3R,light_wvfm[j][24:48])\n", + " l_mod2_4R = np.add(l_mod2_4R,light_wvfm[j][48:72])\n", + " l_mod2_4L = np.add(l_mod2_4L,light_wvfm[j][72:96])\n", + "\n", + " if opt_chan[j][0]==192:\n", + " l_mod3_5L = np.add(l_mod3_5L,np.array(light_wvfm[j][0:24]))\n", + " l_mod3_5R = np.add(l_mod3_5R,np.array(light_wvfm[j][24:48]))\n", + " l_mod3_6R = np.add(l_mod3_6R,np.array(light_wvfm[j][48:72]))\n", + " l_mod3_6L = np.add(l_mod3_6L,np.array(light_wvfm[j][72:96])) \n", + "\n", + " if opt_chan[j][0] == 288:\n", + " l_mod4_7L = np.add(l_mod4_7L,np.array(light_wvfm[j][0:24]))\n", + " l_mod4_7R = np.add(l_mod4_7R,np.array(light_wvfm[j][24:48]))\n", + " l_mod4_8R = np.add(l_mod4_8R,np.array(light_wvfm[j][48:72]))\n", + " l_mod4_8L = np.add(l_mod4_8L,np.array(light_wvfm[j][72:96])) " + ] + }, + { + "cell_type": "markdown", + "id": "b65fe5fc", + "metadata": {}, + "source": [ + "## Comparing Light And Charge:\n", + " The code below uses backtracking between the packets and tracks datasets to plot charge tracks in the\n", + " volume alongside light waveform sums. It's a useful visual, but not a global check of light/charge \n", + " correlation.\n", + " \n", + " This code splits the detector into TPCs, pairing TPCs that align in the beam direction." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "4909384e", + "metadata": {}, + "outputs": [], + "source": [ + "def data_readout(io_first, io_second, spill):\n", + " \n", + "## SET UP AN 18-PLOT DISPLAY \n", + " fig = plt.figure(figsize=(13.8,8),tight_layout=True)\n", + " subfigs = fig.subfigures(1, 6, wspace=0, width_ratios=[0.8,1.5,0.8,0.8,1.5,0.8], height_ratios=[1])\n", + " axs0 = subfigs[0].subplots(4, 1,sharey=True,gridspec_kw={'hspace': 0})\n", + " axs1 = subfigs[1].subplots(1, 1)\n", + " axs2 = subfigs[2].subplots(4, 1,sharey=True,gridspec_kw={'hspace': 0})\n", + " axs3 = subfigs[3].subplots(4, 1,sharey=True,gridspec_kw={'hspace': 0})\n", + " axs4 = subfigs[4].subplots(1, 1)\n", + " axs5 = subfigs[5].subplots(4, 1,sharey=True,gridspec_kw={'hspace': 0})\n", + "\n", + "## CREATE AN EMPTY ARRAY TO AVOID RE-PLOTTING TRACKS\n", + " plotted_tracks = []\n", + "\n", + "## SET UP LABELING AND COLOR SCHEME\n", + " titles = [\"mod. 2, io_group 3\",\"mod. 1, io_group 1\",\"mod. 2, io_group 4\",\"mod. 1, io_group 2\",\n", + " \"mod. 4, io_group 7\",\"mod. 3, io_group 5\",\"mod. 4, io_group 8\",\"mod. 3, io_group 6\"]\n", + " colors = ['aqua','aqua','lightgreen','lightgreen','yellow','yellow','orangered','orangered']\n", + " cmap = cm.jet\n", + " \n", + "## ENFORCE GEOMETRY\n", + " ios = [3,1,4,2,7,5,8,6]\n", + " left_data = [l_mod2_3L,l_mod1_1L,l_mod2_4L,l_mod1_2L,l_mod4_7L,l_mod3_5L,l_mod4_8L,l_mod3_6L]\n", + " right_data = [l_mod2_3R,l_mod1_1R,l_mod2_4R,l_mod1_2R,l_mod4_7R,l_mod3_5R,l_mod4_8R,l_mod3_6R]\n", + "\n", + "## ENSURE THE TIMESTAMP TURNOVER ISN'T AN ISSUE\n", + " packet_list = packets[pack_type==0][packet0_spillIDs==spill]\n", + " mc_assoc = mc_assn[pack_type==0][packet0_spillIDs==spill]\n", + "\n", + "## MAP PACKETS TO TRACKS\n", + " for ip,packet in enumerate(packet_list):\n", + " track_ids = mc_assoc['track_ids'][ip]\n", + " io_group = packet['io_group']\n", + "\n", + "## GET THE POSITION OF CHARGE TRACKS AND SAVE TO THE CORRECT IO_GROUP\n", + " for trackid in track_ids:\n", + " if trackid >= 0 and trackid not in plotted_tracks:\n", + " plotted_tracks.append(trackid)\n", + " if io_group==io_first:\n", + " X = (tracks[trackid]['x_start']*10,tracks[trackid]['x_end']*10)\n", + " Y = (tracks[trackid]['y_start']*10,tracks[trackid]['y_end']*10)\n", + " Z = (tracks[trackid]['z_start']*10,tracks[trackid]['z_end']*10)\n", + " axs1.plot(Z,Y,c=colors[ios.index(io_first)],alpha=1,lw=1.5)\n", + " if io_group==io_second:\n", + " X = (tracks[trackid]['x_start']*10,tracks[trackid]['x_end']*10)\n", + " Y = (tracks[trackid]['y_start']*10,tracks[trackid]['y_end']*10)\n", + " Z = (tracks[trackid]['z_start']*10,tracks[trackid]['z_end']*10)\n", + " axs4.plot(Z,Y,c=colors[ios.index(io_second)],alpha=1,lw=1.5)\n", + " else:\n", + " axs1.plot(0,0,c='navy',alpha=0.1)\n", + " axs4.plot(0,0,c='navy',alpha=0.1)\n", + "\n", + "## LABEL THE LIGHT PLOTS \n", + " axs0[0].set_title(\"Left:\\nio_group \"+str(io_first))\n", + " axs2[0].set_title(\"Right:\\nio_group \"+str(io_first))\n", + " axs3[0].set_title(\"Left:\\nio_group \"+str(io_second))\n", + " axs5[0].set_title(\"Right:\\nio_group \"+str(io_second))\n", + " axs0[3].set_xlabel(r\"Samples [0.01 $\\mu$s]\")\n", + " axs2[3].set_xlabel(r\"Samples [0.01 $\\mu$s]\")\n", + " axs3[3].set_xlabel(r\"Samples [0.01 $\\mu$s]\")\n", + " axs5[3].set_xlabel(r\"Samples [0.01 $\\mu$s]\")\n", + " fig.supylabel(\"Pulse Sum Over Light Collection Module\",x=-0.07,y=0.53)\n", + "\n", + "## SUM THE LIGHT DATA (IN PARTS) \n", + " all_sums=[]\n", + " for i in range(4):\n", + " if (i%2)==0:\n", + " clr = 'greenyellow'\n", + " else:\n", + " clr = 'lightgreen'\n", + " wvfm_scndL = [sum(w) for w in zip(*(left_data[ios.index(io_second)])[SiPM_struct==i]/BIT)]\n", + " wvfm_scndR = [sum(w) for w in zip(*(right_data[ios.index(io_second)])[SiPM_struct==i]/BIT)]\n", + " wvfm_frstL = [sum(w) for w in zip(*(left_data[ios.index(io_first)])[SiPM_struct==i]/BIT)]\n", + " wvfm_frstR = [sum(w) for w in zip(*(right_data[ios.index(io_first)])[SiPM_struct==i]/BIT)]\n", + " \n", + " all_sums.extend(wvfm_scndL+wvfm_scndR+wvfm_frstL+wvfm_frstR)\n", + " \n", + "## SET UNIVERSAL AXIS LIMITS\n", + " y_min = (min(all_sums)-500)\n", + " y_max = (max(all_sums))\n", + "\n", + "## PLOT LIGHT WAVEFORMS\n", + " axs0[i].plot(np.linspace(0,SAMPLES-1,SAMPLES),wvfm_frstL,color='k')\n", + " axs0[i].set_facecolor(clr) \n", + " axs0[i].set_box_aspect(1)\n", + " axs0[i].label_outer()\n", + " axs0[i].set_ylim(y_min,y_max)\n", + " \n", + " axs2[i].plot(np.linspace(0,SAMPLES-1,SAMPLES),wvfm_frstR,color='k')\n", + " axs2[i].set_facecolor(clr)\n", + " axs2[i].label_outer()\n", + " axs2[i].set_box_aspect(1)\n", + " axs2[i].set_ylim(y_min,y_max)\n", + " axs2[i].yaxis.set_ticklabels([])\n", + " \n", + " axs3[i].plot(np.linspace(0,SAMPLES-1,SAMPLES),wvfm_scndL,color='k')\n", + " axs3[i].set_facecolor(clr)\n", + " axs3[i].label_outer()\n", + " axs3[i].set_box_aspect(1)\n", + " axs3[i].set_ylim(y_min,y_max)\n", + " axs3[i].yaxis.set_ticklabels([])\n", + " \n", + " axs5[i].plot(np.linspace(0,SAMPLES-1,SAMPLES),wvfm_scndR,color='k')\n", + " axs5[i].set_facecolor(clr)\n", + " axs5[i].label_outer()\n", + " axs5[i].set_box_aspect(1)\n", + " axs5[i].set_ylim(y_min,y_max)\n", + " axs5[i].yaxis.set_ticklabels([])\n", + "\n", + "## COLOR THE CHARGE PLOTS\n", + " tpc_rectL = plt.Rectangle((-655,-240), 640, 1340, linewidth=0.75, edgecolor='b', facecolor=cmap(0),zorder=-1)\n", + " tpc_rectR = plt.Rectangle((15,-240), 640, 1340, linewidth=0.75, edgecolor='b', facecolor=cmap(0),zorder=-1)\n", + "\n", + "## LABEL THE CHARGE PLOTS \n", + " axs1.add_patch(tpc_rectL)\n", + " axs1.set_aspect(\"equal\")\n", + " axs1.set_xlabel(\"z [mm]\")\n", + " axs1.set_ylim(-240,1100)\n", + " axs1.set_title(titles[ios.index(io_first)])\n", + " axs1.yaxis.set_ticklabels([]) \n", + "\n", + " axs4.add_patch(tpc_rectR) \n", + " axs4.set_xlabel(\"z [mm]\")\n", + " axs4.set_ylim(-240,1100)\n", + " axs4.set_aspect(\"equal\")\n", + " axs4.set_title(titles[ios.index(io_second)])\n", + " axs4.yaxis.set_ticklabels([]) \n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "fe9fba8d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data_readout(3,1,SPILL)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "807d2209", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data_readout(4,2,SPILL)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "5810337a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data_readout(7,5,SPILL)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "535b57b2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data_readout(8,6,SPILL)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5b2a457", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c14ec3c1f4c60600137feed0dd12a68dd6f74be9 Mon Sep 17 00:00:00 2001 From: drinkingkazu Date: Fri, 19 May 2023 14:29:29 -0700 Subject: [PATCH 2/3] attempt for a better fraction information --- larndsim/detsim.py | 2 +- larndsim/fee.py | 30 +++++++++++++++++++++++++----- 2 files changed, 26 insertions(+), 6 deletions(-) diff --git a/larndsim/detsim.py b/larndsim/detsim.py index 9885b514..086f5e92 100644 --- a/larndsim/detsim.py +++ b/larndsim/detsim.py @@ -14,7 +14,7 @@ from .consts import detector from .pixels_from_track import id2pixel -MAX_TRACKS_PER_PIXEL = 5 +MAX_TRACKS_PER_PIXEL = 100 MIN_STEP_SIZE = 0.001 # cm MC_SAMPLE_MULTIPLIER = 1 diff --git a/larndsim/fee.py b/larndsim/fee.py index 7f73658f..f5d02d38 100644 --- a/larndsim/fee.py +++ b/larndsim/fee.py @@ -21,8 +21,10 @@ from .consts.units import mV, e from .consts import units +#: Number of back-tracked segments to be recorded +TRACK_ASSOCIATION_COUNT = 10 #: Maximum number of ADC values stored per pixel -MAX_ADC_VALUES = 20 +MAX_ADC_VALUES = 100 #: Discrimination threshold in e- DISCRIMINATION_THRESHOLD = 7e3 * e #: ADC hold delay in clock cycles @@ -277,8 +279,26 @@ def export_to_hdf5(event_id_list, packet_list = PacketCollection(packets, read_id=0, message='') hdf5format.to_file(filename, packet_list, workers=1) packets_mc_ds = np.empty(len(packets), dtype=dtype) - packets_mc_ds['track_ids'] = packets_mc - packets_mc_ds['fraction'] = packets_frac + + # First, sort the back-tracking information by the magnitude of the fraction + frac_order = np.flip(np.argsort(np.abs(packets_frac),axis=1),axis=1) + ass_track_ids = np.take_along_axis(packets_mc, frac_order, axis=1) + ass_fractions = np.take_along_axis(packets_frac, frac_order, axis=1) + + # Second, only store the relevant portion. + if packets_mc.shape[1] >= TRACK_ASSOCIATION_COUNT: + packets_mc_ds['track_ids'] = packets_mc [:,:TRACK_ASSOCIATION_COUNT] + packets_mc_ds['fraction' ] = packets_frac [:,:TRACK_ASSOCIATION_COUNT] + else: + num_to_pad = TRACK_ASSOCIATION_COUNT - packets_mc.shape[1] + packets_mc_ds['track_ids'] = np.pad(packets_mc, + pad_width=((0,0),(0,num_to_pad)), + mode='constant', + constant_values=-1) + packets_mc_ds['fraction' ] = np.pad(packets_frac, + pad_width=((0,0),(0,num_to_pad)), + mode='constant', + constant_values=0.) with h5py.File(filename, 'a') as f: if is_first_event: @@ -425,9 +445,9 @@ def get_adc_values(pixels_signals, for itrk in range(current_fractions.shape[2]): tot_backtracked += current_fractions[ip][iadc][itrk] - if tot_backtracked != 0: + if q_sum > 0: for itrk in range(current_fractions.shape[2]): - current_fractions[ip][iadc][itrk] /= tot_backtracked + current_fractions[ip][iadc][itrk] /= q_sum adc_list[ip][iadc] = adc From 151e860d8da0acbb08bc3bd3b16eecdb368ab54d Mon Sep 17 00:00:00 2001 From: drinkingkazu Date: Fri, 19 May 2023 17:40:58 -0700 Subject: [PATCH 3/3] pushing to the right branch! --- larndsim/detsim.py | 2 +- larndsim/fee.py | 23 ++++++++++++++--------- 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/larndsim/detsim.py b/larndsim/detsim.py index 086f5e92..dfe7aa2c 100644 --- a/larndsim/detsim.py +++ b/larndsim/detsim.py @@ -14,7 +14,7 @@ from .consts import detector from .pixels_from_track import id2pixel -MAX_TRACKS_PER_PIXEL = 100 +MAX_TRACKS_PER_PIXEL = 20 MIN_STEP_SIZE = 0.001 # cm MC_SAMPLE_MULTIPLIER = 1 diff --git a/larndsim/fee.py b/larndsim/fee.py index f5d02d38..cc225b1a 100644 --- a/larndsim/fee.py +++ b/larndsim/fee.py @@ -22,9 +22,9 @@ from .consts import units #: Number of back-tracked segments to be recorded -TRACK_ASSOCIATION_COUNT = 10 +ASSOCIATION_COUNT_TO_STORE = 10 #: Maximum number of ADC values stored per pixel -MAX_ADC_VALUES = 100 +MAX_ADC_VALUES = 20 #: Discrimination threshold in e- DISCRIMINATION_THRESHOLD = 7e3 * e #: ADC hold delay in clock cycles @@ -143,7 +143,6 @@ def export_to_hdf5(event_id_list, Returns: tuple: a tuple containing the list of LArPix packets and the list of entries for the `mc_packets_assn` dataset """ - dtype = np.dtype([('track_ids', f'({track_ids.shape[1]},)i8'), ('fraction', f'({current_fractions.shape[2]},)f8')]) io_groups = np.unique(np.array(list(detector.MODULE_TO_IO_GROUPS.values()))) packets = [] @@ -278,24 +277,30 @@ def export_to_hdf5(event_id_list, if packets: packet_list = PacketCollection(packets, read_id=0, message='') hdf5format.to_file(filename, packet_list, workers=1) + + dtype = np.dtype([('track_ids',f'({ASSOCIATION_COUNT_TO_STORE},)i8'), + ('fraction', f'({ASSOCIATION_COUNT_TO_STORE},)f8')]) packets_mc_ds = np.empty(len(packets), dtype=dtype) # First, sort the back-tracking information by the magnitude of the fraction + packets_frac = np.array(packets_frac) + packets_mc = np.array(packets_mc) + frac_order = np.flip(np.argsort(np.abs(packets_frac),axis=1),axis=1) ass_track_ids = np.take_along_axis(packets_mc, frac_order, axis=1) ass_fractions = np.take_along_axis(packets_frac, frac_order, axis=1) # Second, only store the relevant portion. - if packets_mc.shape[1] >= TRACK_ASSOCIATION_COUNT: - packets_mc_ds['track_ids'] = packets_mc [:,:TRACK_ASSOCIATION_COUNT] - packets_mc_ds['fraction' ] = packets_frac [:,:TRACK_ASSOCIATION_COUNT] + if ass_track_ids.shape[1] >= ASSOCIATION_COUNT_TO_STORE: + packets_mc_ds['track_ids'] = ass_track_ids[:,:ASSOCIATION_COUNT_TO_STORE] + packets_mc_ds['fraction' ] = ass_fractions[:,:ASSOCIATION_COUNT_TO_STORE] else: - num_to_pad = TRACK_ASSOCIATION_COUNT - packets_mc.shape[1] - packets_mc_ds['track_ids'] = np.pad(packets_mc, + num_to_pad = ASSOCIATION_COUNT_TO_STORE - ass_track_ids.shape[1] + packets_mc_ds['track_ids'] = np.pad(ass_track_ids, pad_width=((0,0),(0,num_to_pad)), mode='constant', constant_values=-1) - packets_mc_ds['fraction' ] = np.pad(packets_frac, + packets_mc_ds['fraction' ] = np.pad(ass_fractions, pad_width=((0,0),(0,num_to_pad)), mode='constant', constant_values=0.)