diff --git a/calo_images_piplus.ipynb b/calo_images_piplus.ipynb index 3f4f86d..49bc2a0 100755 --- a/calo_images_piplus.ipynb +++ b/calo_images_piplus.ipynb @@ -24,23 +24,35 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "file_name='DplusMuNu_Full'\n", - "file_path='/disk/lhcb_data/davide/HCAL_project_full_event/'+file_name+'.root'\n", - "tree_name='ntuple/DecayTree'" - ] - }, - { - "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ + "\n", + "file_name='B2Dmunu_full'\n", + "file_path='/disk/lhcb_data/davide/HCAL_project_full_event/'+file_name+'.root'\n", + "tree_name='Bd2Dmu/DecayTree'\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ "f = r.TFile(file_path)\n", - "t = f.Get(tree_name)" + "t = f.Get(tree_name)\n", + "j=t.GetEntries()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#b=r.TBrowser()" ] }, { @@ -49,17 +61,8 @@ "metadata": {}, "outputs": [], "source": [ - "j=t.GetEntries()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "batch_size=25000\n", - "#n_batches=3\n", + "batch_size=20000\n", + "#n_batches=2\n", "N = j\n", "n_batches= N//batch_size" ] @@ -70,7 +73,7 @@ "metadata": {}, "outputs": [], "source": [ - "particle = 'piplus'\n", + "particle = 'pi1'\n", "variable = 'ET'\n", "\n", "cal_zone = 'inner'\n", @@ -81,7 +84,7 @@ " cellsET_inner_dict[j]=rn.root2array(\n", " filenames=file_path, \n", " treename=tree_name,\n", - " branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,\n", + " branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,#\"B0_L0HadronDecision_TOS\",\"B0_L0HadronDecision_TIS\"],\n", " start=j*batch_size,\n", " stop=(j+1)*batch_size,\n", " )\n", @@ -94,14 +97,14 @@ " cellsET_inner_dict[j+1]=rn.root2array(\n", " filenames=file_path,\n", " treename=tree_name,\n", - " branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,\n", + " branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,# \"B0_L0HadronDecision_TOS\",\"B0_L0HadronDecision_TIS\"],\n", " start=n_batches*batch_size,\n", " stop=N,\n", " ) \n", " cellsET_inner_dict[j+1]=np.array([cellsET_inner_dict[j+1][i] for i in range((N % batch_size))])\n", " np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1), cellsET_inner_dict[j+1])\n", " \n", - "particle = 'piplus'\n", + "particle = 'pi1'\n", "variable = 'ET'\n", "\n", "cal_zone='outer'\n", @@ -112,7 +115,7 @@ " cellsET_outer_dict[j]=rn.root2array(\n", " filenames=file_path, \n", " treename=tree_name,\n", - " branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,\n", + " branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,# \"B0_L0HadronDecision_TOS\",\"B0_L0HadronDecision_TIS\"],\n", " start=j*batch_size,\n", " stop=(j+1)*batch_size,\n", " )\n", @@ -124,7 +127,7 @@ " cellsET_outer_dict[j+1]=rn.root2array(\n", " filenames=file_path,\n", " treename=tree_name,\n", - " branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,\n", + " branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,# \"B0_L0HadronDecision_TOS\",\"B0_L0HadronDecision_TIS\"],\n", " start=n_batches*batch_size,\n", " stop=N,\n", " ) \n", @@ -134,32 +137,101 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (, line 6)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m6\u001b[0m\n\u001b[0;31m if cellsET_inner_dict[j][i][1]: and not cellsET_inner_dict[j][i][2]:\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], "source": [ - "batch=10\n", - "n=4" + "cellsET_inner_dict_TOS={}\n", + "\n", + "for j in range(n_batches):\n", + " cellsET_inner_dict_TOS[j]=[]\n", + " for i in range(100):\n", + " if cellsET_inner_dict[j][i][1]: and not cellsET_inner_dict[j][i][2]:\n", + " cellsET_inner_dict_TOS[j].append(cellsET_inner_dict[j][i][0])\n", + " cellsET_inner_dict_TOS[j]=np.array(cellsET_inner_dict_TOS[j])\n", + " \n", + "cellsET_inner_dict_TIS={}\n", + "\n", + "for j in range(n_batches):\n", + " cellsET_inner_dict_TIS[j]=[]\n", + " for i in range(100):\n", + " if cellsET_inner_dict[j][i][2]:\n", + " cellsET_inner_dict_TIS[j].append(cellsET_inner_dict[j][i][0])\n", + " cellsET_inner_dict_TIS[j]=np.array(cellsET_inner_dict_TIS[j])" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "(17, 32, 32)" ] }, - "execution_count": 27, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cellsET_inner_dict_TOS[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "cellsET_outer_dict_TOS={}\n", + "\n", + "for j in range(n_batches):\n", + " cellsET_outer_dict_TOS[j]=[]\n", + " for i in range(100):\n", + " if cellsET_outer_dict[j][i][1] and not cellsET_inner_dict[j][i][2]:\n", + " cellsET_outer_dict_TOS[j].append(cellsET_outer_dict[j][i][0])\n", + " cellsET_outer_dict_TOS[j]=np.array(cellsET_outer_dict_TOS[j])\n", + " \n", + "cellsET_outer_dict_TIS={}\n", + "\n", + "for j in range(n_batches):\n", + " cellsET_outer_dict_TIS[j]=[]\n", + " for i in range(100):\n", + " if cellsET_outer_dict[j][i][2]:\n", + " cellsET_outer_dict_TIS[j].append(cellsET_outer_dict[j][i][0])\n", + " cellsET_outer_dict_TIS[j]=np.array(cellsET_outer_dict_TIS[j])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -171,27 +243,29 @@ } ], "source": [ + "batch=10\n", + "n=4\n", "plt.imshow(cellsET_inner_dict[batch][n],cmap='gray')" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 28, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -203,12 +277,30 @@ } ], "source": [ + "batch=10\n", + "n=4\n", "plt.imshow(cellsET_outer_dict[batch][n],cmap='gray')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "for j in range(n_batches):\n", + "\n", + " np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j), cellsET_inner_dict[j])\n", + " #np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1), cellsET_inner_dict[j+1])\n", + "\n", + " np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j), cellsET_outer_dict[j])\n", + " #np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1), cellsET_outer_dict[j+1]) \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 125, "metadata": {}, "outputs": [], "source": [ @@ -326,6 +418,13 @@ "# cellsY_outer_dict[j+1]=np.array([cellsY_outer_dict[j+1][i] for i in range((N % batch_size))])\n", "# np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1), cellsY_outer_dict[j+1]) " ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/create_reco_images.ipynb b/create_reco_images.ipynb index 88eae01..744bdb9 100644 --- a/create_reco_images.ipynb +++ b/create_reco_images.ipynb @@ -115,10 +115,10 @@ "ET_outer_dict={}\n", "\n", "i=0\n", - "#while os.path.exists('/disk/lhcb_data/davide/HCAL_project_full_event/npy/DplusMuNu_Full/ET_inner/batch_'+str(i)+'.npy'):\n", - "while i < 2:\n", - " ET_inner_dict[i]=np.load('/disk/lhcb_data/davide/HCAL_project_full_event/npy/DplusMuNu_Full/ET_inner/batch_'+str(i)+'.npy')\n", - " ET_outer_dict[i]=np.load('/disk/lhcb_data/davide/HCAL_project_full_event/npy/DplusMuNu_Full/ET_outer/batch_'+str(i)+'.npy')\n", + "while os.path.exists('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu_full/ET_inner/batch_'+str(i)+'.npy'):\n", + "#while i < 2:\n", + " ET_inner_dict[i]=np.load('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu_full/ET_inner/batch_'+str(i)+'.npy')\n", + " ET_outer_dict[i]=np.load('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu_full/ET_outer/batch_'+str(i)+'.npy')\n", "\n", " i+=1\n", " " @@ -131,7 +131,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -155,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -164,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -177,14 +177,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "((25000, 28, 32), (25000, 26, 32))\n" + "((20000, 28, 32), (20000, 26, 32))\n" ] } ], @@ -197,7 +197,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -226,31 +226,32 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ - "ET_inner_filtered, ET_outer_filtered = delete_undetected_events(ET_inner_dict,ET_outer_dict)" + "\n", + "ET_inner_filtered, ET_outer_filtered = delete_undetected_events(ET_inner_dict,ET_outer_dict)\n" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAACoCAYAAADw6BWzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAE39JREFUeJzt3WuMXdV5xvH/OzZDcSkOrgGNbGgCRRFWRVyBwBVRZZm6cpHAVEqqUNFQCeR8iKWmikhMKjUUqQKaBPqhJSqRERS1BGibABUqtaxYtBIkGS51CJgYLOqMsXwJDhdZYjzM2w9nTzWzz5o56+z73uf5SaOZs7wv75k5Xj5ez6y1zN0REZH2G6u7ABERKYY6dBGRjlCHLiLSEerQRUQ6Qh26iEhHqEMXEekIdegiIh2hDl1EpCNydehmtsXMXjezN8xsR1FFiYjI8CzrTFEzWwb8DNgMTAE/Bm5w91eLK09ERGItz3HuFcAb7n4AwMy+C2wFFu3QzazV6wyYWV/bKCyd0Kbn7e79xYqMiDwd+hrg5/MeTwFX5iun2cbHx/vaPvzwwxoqqdaoPm+RtsnToYfeCfW9bTOzbcC2HPcREZEIeULRKeD8eY/XAm+nD3L3+939cne/PMe9RCqlwF/aKE8oupxeKHo1cIheKPrH7v7TJc5p5sBrDqeffvqCx2UPRaTv16R7ho6LUWT9RYyhZwn8u/jabpN0zlN0xhPKkdJi75n1WjGv7cxDLu4+Y2bbgWeAZcADS3XmIi0ydOAv9Vq+fGFXdurUqVKvHxJ7zyKv1XftTGcl3P1p4Ok81xBpoJEL/KUbcnXoIh2lwF9aSR26SL/owB+4HzSGLs2QORTNdLPAi77IkC8mlNPvT3dbQaHo0IH/2NiYlzmOe9ppp/W1xVw/63l5hO5ZdQ1lq+P7WmooKtJVCvylrdShiwQo8Jc20vK5IiIdUfs79CLHtIu8VtbJNHXUUIestVV9nsgoqb1DF5HBQoFbOpgLHVNH+Bhzz8suuyzqvL179xZSU9GaEHiHaMhFRKQj1KGLiHSEOnQRkY7QGDr5ArcyQ9DYa9cRGFYdSDY9AHX3ysermzo5JzQmvHLlygWPJycn+47ZtGlT1LVCbRdccMGCx/v27RtYZx5FjnsX+XPUO3QRkY5Qhy4i0hHq0EVEOiLXGLqZvQW8D3wEzGibORGR+uRabTHp0C939+ORx9e+xGie7dRi2o4dOxZVx1lnndXX9t5770Wdm9UobJdXxGqLWYRe21WvOljHCoBZ64ittcjnVPY9yz4v5rWtIRcRkY7I26E78J9m9kKye4uIiNQk7++hX+Xub5vZucAuM9vn7s/OP0DbdImIVCPvJtFvJ5+Pmtn36O2W/mzqGG3TJa2jwF/aKHMoama/Coy5+/vJ17uAO9z9P5Y4p7AOvezArcjrn3POOVHXSreVPVO0i0vSFhWKtiHwj1ltMea8Yc7NKmutdYgJs8uWNRTN8w79POB7ZjZ3nX9eqjMXEZFyZe7Q3f0A8KkCaxFpkrnA34F/SIYORRpNi3OJhCnwl9ZpZIceMwEm1BaarBMzJhw6JjTuPTU1NfBaIWvWrOlrO3ToUF9bzMSi0HMMyfq88wiNyWe9Z8xrIH3M9PR01LVjKPCXNmpkhy5Sp0Dg//vAHQPOYfnyhX+dyg7+mrBca5PvmVWRta5YsaKv7eTJk4VdP00dukg/Bf7SSurQRVIU+EtbaS0XEZGOyLXa4tA3yxgc5ZkAkz43T9iZtY7Q9zj573yligwtq77+RRdd1NeWDpFPnDjBqVOnGrPaYoymrJAo+d166619bc8880xf2969ewdeK/26mJmZYXZ2VqstioiMCnXoIiIdoQ5dRKQj1KGLiHREa0PRkJjALXY2aeieoZmcZQaBRT7vPPfMukVf2VvqhTR9C7ombGUmzRKzuqNCURGREaMOXUSkI9Shi4h0xMAO3cweMLOjZvbKvLZVZrbLzPYnn88ut0wRERlkYChqZr8LfAD8o7v/VtL2N8A77n6Xme0Aznb3rw68WclLjMYEekXOOo09JhQOrl+/vq/twIEDA+uKDXWLDCSL3KouNuhNCz3vY8eO9bXVFYqOjY151asttmlbN8kv5rU98B16sqj/O6nmrcBDydcPAdcPXZ2IiBQq6xj6ee5+GCD5fG5xJYmISBalh6Jmts3MJs1ssux7iQxD+ZB0TdYO/YiZTQAkn48udqC73+/ul7v75RnvJVKWB4EtqbYdwG53vxjYnTwWaYWsG1w8CdwE3JV8fqKwinLIuo9mKKgLLbMbEw6Gwsi1a9f2tW3Zku5H4L777utrSyt79mXs9yIUSKbF7gUbumc6BI2p68SJEwNrms/dnzWzj6eatwIbk68fAvYAAwN/dy81lNQs0OqElmo+ePDggserV6/uO+b48eN9bVl/RqHlc2PE/NriI8BzwCfNbMrMbqbXkW82s/3A5uSxSBcoH5LWGvgO3d1vWOSPri64FpFWMbNtwLa66xCZo5miIgspH5LWqnS1xbGxMR8fHx94XHqcNTSpJOtYcuwkmXXr1kXd85Zbblnw+OGHH+47JjTeXORYeOj7EzMRJ/S8N2zY0Nf20ksv9bWFzk1nBaHnHTuGftttty14fOedd0Zda9iJRckY+r/PmzT3DeAX8ybNrXL3rwy6Th0Ti6QcMXlF6JhQ28mTJwu5HxQ0sUikq5QPSddk/S0XkdZTPiRdo3foIiIdoQ5dRKQjWrsFXdmr/cXeMz25ZWpqKlNdVUgHpbETf0JCk6XSQW+e4DdmYlGTVlvM+tqO2X4MtAVdlVasWNHXlg436/heKxQVERkh6tBFRDpCHbqISEeoQxcR6YhWhKIhseFm1vA09p433njjgsc7d+4s7H5FS9f6+OOPF3r9mO3+ss76jf05ti0UleYJraS4ffv2BY/vvffevmPefffdvrbY0HuQmZkZZmdnFYqKiIwKdegiIh0Rsx56aJuu283skJm9nHxcU26ZIiIySMw79Afp36YL4F53X598PF1sWSIiMqyoUDSwxOjtwAfu/s2hblbyTNHYoDTmWqGZkKHj0ttVhQK+UBD4/PPPD1PikkK1hgLPjRs3Zrp+6Psaumd65mbMNnV5akibnp6OCo7KELt8bjoki51dGBOuZV2+VYqxcuXKvrZQUBojtAVd2aHodjPbmwzJaGd0EZGaZe3Qvw1cBKwHDgPfWuxAM9tmZpNmNpnxXiIiEiFTh+7uR9z9I3efBb4DXLHEsdqmSxpJgb90TaYOfW7PxcQfAq8sdqxIgz2IAn/pkIE7FiXbdG0EVpvZFPB1YKOZrQcceAv4QszNzIz0nqKhsCsdLMbOEowJSkP3Sy+Bu5iYvUFD1wqdFzoufa08s2HvueeeTOfFzuR89dVX+9pi6s26FHKRM37nuPuzSeBfxLWi9p0schnciYmJBY9Dody+ffsG3k8Wivn+h5bYDX3/Q6F0zGsg61K8Azv0Rbbpau78dpH8tpvZ54FJ4MvufqLugkRiaKaoyEIK/KW11KGLzKPAX9ps4JBLkcysbww1Ztw7z/hpzLmhMe7Ye6ZrDY03x14rPfFnz549fcekJzIBvPnmm31tzz333MD7Fbm1X+y5ZYyFF8nMJtz9cPIwV+CfdWJR7Pjp8ePHFzy+9NJL+47RGPrwYn5ud999d98xjz76aF/bwYMHB16ryK3rKu3QRZqkyMBfpAnUocvIUuAvXaMxdBGRjlCHLiLSEZVuQbds2TI/88wzF7SFQsQiQ9Gsily5MXa1wqmpqUz3jJ0MlL5n7P2aHmTO1/Qt6GICsawTkkKTXbTaYvNkDUVjXtt6hy4i0hHq0EVEOkIduohIR6hDFxHpiEpD0TPOOMMvvPDCBW2hVfuKVGTAGgo3s14/Zju70AzQmBogbiu8mEB6GE0IT+sKRWO3oCtT1jBVihGzTSD0/0xif24KRUVERog6dBGRjhjYoZvZ+Wb2AzN7zcx+amZ/lrSvMrNdZrY/+ayNokVEahTzDn2G3iL/lwAbgC+a2TpgB7Db3S8GdiePRUSkJkOHomb2BPB3ycdGdz+c7DG6x90/OeDc6hLYIeTZ6i0dNIauFVqeN2tdsTNRYwLK2O3yQkKzU9P3rCMk7WooqsBTCg9Fk/0Xfxv4IXDe3LrRyedzhy9RRESKEr18rpmdCfwr8CV3f88s7o2QmW0DtmUrT0REYkW9Qzez0+h15v/k7v+WNB9JhlpIPh8NnattuqSpFPhL1wwcQ7feW/GHgHfc/Uvz2r8B/MLd7zKzHcAqd//KgGs1cgy9bEVv9ZZVesz8uuuu6ztm587s+zvEZBFFPu/0/aanp5mdnY0eQ0/eiEy4+4tm9mvAC8D1wJ/Se73PvbbPdvevDrhWptd27Nh41jH0rJNdACYmJhY8Pnz4cN8xTRHzPNuUOaSfz8zMTNRrO+Yd+lXAnwCbzOzl5OMa4C5gs5ntBzYnj0Vaw90Pu/uLydfvA68Ba4Ct9N7EkHy+vp4KRYYzcAzd3f8bWOxfhquLLUekHksF/mamwF9aQXuKyshT4C9doan/MtIU+EuXVLra4tjYmI+Pjy9oiwnJmhIqVi12a7nYiVHp49IrXwIcOHAg6p5ly7qK5TATi8oO/KsOMssOWENWr17d13b8+PFM12qKpk7iinlta8hFRtlc4P8TM3s5afsavYD/MTO7GTgIfLam+kSGog5dRpYCf+kajaGLiHSEOnQRkY6oNBQd1ZmisdJBYOzWclnFrJi4WFtT1bXaYtmv7SYEdWXXEBsGZ9WEYDMPbUEnIjJC1KGLiHSEOnQRkY5Qhy4i0hGN/D30rLMEY64VErp+nu3ZsorZwi1UVygoLXsGbtZzs26r1/Rg1swoagu6IsPHPNdKn1t2qJjn+ula8ywbXFQNRV8/ht6hi4h0hDp0EZGOGNihL7FN1+1mdii16YWIiNQkZgx9Bvjy/G26zGxX8mf3uvs3yytPpB3cvbDx0iLHXfNcq8zx5aJXgUwfV8ckoqz3fOqpp/rarr322kzXitmx6DAwt3vL+2Y2t03X0MyMmOVziwzAsl6r7AA0q9gANCZ8DD3H0Hmxy/PGiP15ZAlYp6enM9Uk0hVDjaGntukC2G5me83sAe2MLiJSr+gOPb1NF/Bt4CJgPb138N9a5LxtZjZpZpNVrhsjIjJqojr00DZd7n7E3T9y91ngO8AVoXPnb9MVu1ejSBUU+EvXDFxtcYltuibmdkY3sz8HrnT3zw24Vmveohe57V3sZKAYZU+yKvKeRU5cKmkLuglgYn7gD1wP/BHwwTCBf+xru8jJOlmvlXWrujqCxiZM1gnVUXYN6fvNzMwwOztbyBZ0i23TdYOZrQcceAv4wjAFi9StyMBfpAlifstlsW26ni6+HJF6pAL/q+gF/p8HJun92u6J+qoTiaOZojLyigj8KytWZAnq0GWkFRX4V1exyOJq34IuJjgrMqAMWbt2bV/b1NRUYddvk7ZvSzdkKFpk4H8M+F9gNXA8S+0N0eb621w7LF3/b7h7/29XpDRy+VyRihQW+M/9ZUvmW7T2HXub629z7VBM/erQZWQp8Jeu0Ri6iEhHqEMXKdb9dReQU5vrb3PtUED9VYeiCo7q1+baoYDgSKSrKu3Q//+mCi9q0+baof31i5RJQy4iBTCzLWb2upm9YWY76q5nkGTJ66Nm9sq8tlVmtsvM9iefG7kk9hKLqrWl/l8xsx+Z2f8k9f9V0v4JM/thUv+jZjY+6Fpp6tBFcjKzZcDfA38ArKP3a4/r6q1qoAeBLam2HcBud78Y2J08bqK5XdQuATYAX0y+322p/0Ngk7t/it5s5C1mtgG4m94ucBcDJ4Cbh71wXR36yIcXNWpz7dDM+q8A3nD3A+4+DXwX2FpzTUty92eBd1LNW+lNtCL5fH2lRUVy98Pu/mLy9fvA3KJqbanf3f2D5OFpyYcDm4B/Sdoz1V9Lh+7uTfxLGa3N9be5dmhs/WuAn897PEU7V208b26GbPL53JrrGSi1qFpr6jezZclktqPALuBN4JfuPpMckuk1pCEXkfxCk5Nas/Z/WwUWVWuNZK2g9cBaev/DuyR02LDXrbxDV3hUnTaHR2UGRyWYAs6f93gt8HZNteRxJNn0Y27zj6M117Oo0KJqtKj+Oe7+S2APvSzgY2Y2N3s/02uo0g5d4VHl2hwelRYcleDHwMXJPzbjwOeAJ2uuKYsngZuSr28CnqixlkUli6rtBF5z93vm/VFb6j/HzD6WfH0G8Hv0coAfAJ9JDstWv7tX9gH8DvDMvMe3AbdVWUPGuj8OvDLv8ev0ti4DmABer7vGyOfxBLC5bfUDK4AXgSvpTSpaHno91VzjNcDP6I2F/kXd9UTU+wi9td5P0fsfxs3Ar9P7B35/8nlV3XUuUvun6Q1H7AVeTj6uaVH9lwIvJfW/Avxl0n4h8CPgDeBx4PRhr1314lyh8OjKimsowoLwxcwaG77MWSo8amr9yf/oXgB+k97/7AoJjsrg7k/TokW93P2GRf7o6koLycAXX1QN2lH/Xnp/F9PtB1hk7f1YVY+hKzyqQVvDIy8pOBLpqqo7dIVHFetCeOQFB0ciXVV1h67wqEJtDo9KDY5EOqryxbnM7Brgb4FlwAPu/teVFjAkM3sE2Ehvlb8jwNeB7wOPARcAB4HPunt61l3tzOzTwH8BPwFmk+av0RtHb3T9ZnYpvdlyy+i98XjM3e8wswvpzcRcRS9YutHdm7kfnkjFalltUUREiqeZoiIiHaEOXUSkI9Shi4h0hDp0EZGOUIcuItIR6tBFRDpCHbqISEeoQxcR6Yj/A05Mv1efuboCAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -263,29 +264,29 @@ ], "source": [ "plt.subplot(1,2,1)\n", - "plt.imshow(ET_inner_filtered[0][1].reshape(28,32),cmap='gray')\n", + "plt.imshow(ET_inner_filtered[0][2].reshape(28,32),cmap='gray')\n", "plt.subplot(1,2,2)\n", - "plt.imshow(ET_outer_filtered[0][1].reshape(26,32),cmap='gray')" + "plt.imshow(ET_outer_filtered[0][2].reshape(26,32),cmap='gray')" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -297,13 +298,15 @@ } ], "source": [ - "i=1\n", - "plt.imshow(np.flip(insert(ET_inner_filtered[0][i],double_size(ET_outer_filtered[0][i])).reshape(52,64),axis=0))" + "\n", + "i=11\n", + "plt.imshow(np.flip(insert(ET_inner_filtered[0][i],double_size(ET_outer_filtered[0][i])).reshape(52,64),axis=0))\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -311,7 +314,17 @@ "output_type": "stream", "text": [ "Done batch 1\n", - "Done batch 2\n" + "Done batch 2\n", + "Done batch 3\n", + "Done batch 4\n", + "Done batch 5\n", + "Done batch 6\n", + "Done batch 7\n", + "Done batch 8\n", + "Done batch 9\n", + "Done batch 10\n", + "Done batch 11\n", + "Done batch 12\n" ] } ], @@ -321,16 +334,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(25000, 52, 64, 1)" + "(20000, 52, 64, 1)" ] }, - "execution_count": 16, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -341,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -352,7 +365,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -361,12 +374,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -378,7 +391,7 @@ } ], "source": [ - "plt.hist(a/1000,bins=70);" + "plt.hist(a/1000,range=(0.5,120),bins=70);" ] }, { diff --git a/create_true_images.ipynb b/create_true_images.ipynb index 2de21e7..d075625 100644 --- a/create_true_images.ipynb +++ b/create_true_images.ipynb @@ -20,11 +20,8 @@ "metadata": {}, "outputs": [], "source": [ - "df_piplus = pd.read_csv('/disk/lhcb_data/davide/HCAL_project_full_event/csv/piplus/MCtrue_piplus.csv', index_col=False)\n", - "df_piplus0 = pd.read_csv('/disk/lhcb_data/davide/HCAL_project_full_event/csv/piplus0/MCtrue_piplus0.csv', index_col=False)\n", - "df_Kminus = pd.read_csv('/disk/lhcb_data/davide/HCAL_project_full_event/csv/Kminus/MCtrue_Kminus.csv', index_col=False)\n", - "\n", - "\n" + "with open('/disk/lhcb_data/davide/HCAL_project_full_event/csv/MCtracker_info.pickle', 'rb') as f:\n", + " tracks=pickle.load(f)\n" ] }, { @@ -33,34 +30,34 @@ "metadata": {}, "outputs": [], "source": [ - "true_events_piplus=df_piplus.to_dict(orient='list')\n", - "true_events_piplus0=df_piplus0.to_dict(orient='list')\n", - "true_events_Kminus=df_Kminus.to_dict(orient='list')\n", + "width_X=8404.0\n", + "width_Y=6828.0\n", + "#number of events\n", + "batch_size=20000\n", + "n_batches=11\n", "\n", - "for key in true_events_piplus:\n", - " true_events_piplus[key]=np.array(true_events_piplus[key])\n", - " true_events_piplus0[key]=np.array(true_events_piplus0[key])\n", - " true_events_Kminus[key]=np.array(true_events_Kminus[key])" + "X_pixels=64\n", + "Y_pixels=52" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "#DETERMINE MAX AND MIN X,Y\n", - "max_X=np.max(true_events_piplus['true_x'][np.where(true_events_piplus['region']>=0)])\n", - "min_X=np.min(true_events_piplus['true_x'][np.where(true_events_piplus['region']>=0)])\n", - "\n", - "#width_X=np.ceil(max_X-min_X)\n", - "width_X=8403.0\n", - "\n", - "max_Y=np.max(true_events_piplus['true_y'][np.where(true_events_piplus['region']>=0)])\n", - "min_Y=np.min(true_events_piplus['true_y'][np.where(true_events_piplus['region']>=0)])\n", - "\n", - "#width_Y = np.ceil(max_Y-min_Y)\n", - "width_Y=6812.0" + "len(tracks['xProjections'])" ] }, { @@ -69,253 +66,73 @@ "metadata": {}, "outputs": [], "source": [ - "#number of events\n", - "batch_size=25000\n", - "\n", - "n_batches=2\n", - "save_test_images = False" + "for j in range(n_batches):\n", + " for i in range(batch_size):\n", + " tracks[\"xProjections\"][j][i][0]/=(width_X/2)\n", + " tracks[\"yProjections\"][j][i][0]/=(width_Y/2)\n", + " \n", + " tracks[\"xProjections\"][j][i][0]*=32\n", + " tracks[\"yProjections\"][j][i][0]*=26\n", + " \n", + " tracks[\"xProjections\"][j][i][0]+=32\n", + " tracks[\"yProjections\"][j][i][0]+=26\n", + " " ] }, { "cell_type": "code", "execution_count": 6, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ - "piplus = np.array([{} for i in range(n_batches)])\n", - "piplus0 = np.array([{} for i in range(n_batches)])\n", - "Kminus = np.array([{} for i in range(n_batches)])\n", - "\n", - "for i in range(n_batches):\n", + "pics_dict_flip = {}\n", + "pics_dict = {}\n", + "for n in range(n_batches):\n", " \n", - " for key in true_events_piplus:\n", - " piplus[i][key]= true_events_piplus[key][i*batch_size:(i+1)*batch_size]\n", - " for key in true_events_piplus0:\n", - " piplus0[i][key]= true_events_piplus0[key][i*batch_size:(i+1)*batch_size]\n", - " for key in true_events_Kminus:\n", - " Kminus[i][key]= true_events_Kminus[key][i*batch_size:(i+1)*batch_size]\n", - " " + " pic = np.zeros(shape=(Y_pixels,X_pixels,1),dtype=np.float32)\n", + " batch_size = tracks['regions'][0].shape[0]\n", + " \n", + " pics_dict[n]=np.array([pic for i in range(0,batch_size)])\n", + " pics_dict_flip[n]=np.array([pic for i in range(0,batch_size)])\n", + " \n", + " \n", + " for event in range(batch_size):\n", + " \n", + " for ntrack in range(tracks['yProjections'][n][event][0].shape[0]):\n", + " \n", + " y=int(np.floor(tracks['yProjections'][n][event][0][ntrack]))\n", + " x=int(np.floor(tracks['xProjections'][n][event][0][ntrack]))\n", + " \n", + " if 0=0:\n", - " \n", - " Y_pixels=np.int(np.floor((X_pixels*width_Y)/width_X))\n", - "\n", - " x_values = np.linspace(-X_pixels//2-1,np.ceil(X_pixels/2)+1,X_pixels+3)\n", - " y_values = np.linspace(-Y_pixels//2-1,np.ceil(Y_pixels/2)+1,Y_pixels+3)\n", - "\n", - " X_grid, Y_grid = np.meshgrid(x_values, y_values)\n", - " \n", - " return X_grid, Y_grid, particle_norm" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "X_grid, Y_grid, piplus_norm = create_grid_and_normalise(piplus)\n", - "_, _, piplus0_norm= create_grid_and_normalise(piplus0)\n", - "_, _, Kminus_norm = create_grid_and_normalise(Kminus)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "52" + "" ] }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X_pixels = 64\n", - "Y_pixels = np.int(np.ceil((X_pixels*width_Y)/width_X))\n", - "Y_pixels" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "def make_pics_dict(X_grid, Y_grid, particle, n_batches=n_batches):\n", - " \n", - " pic = np.zeros(shape=(Y_pixels,X_pixels,1),dtype=np.float32)\n", - " pics_dict = {}\n", - " \n", - " for n in range(n_batches):\n", - " \n", - " batch_size = particle[n][\"region\"].shape[0]\n", - " pics_dict[n]=np.array([pic for i in range(0,batch_size)])\n", - " \n", - " for k in range(batch_size):\n", - " event=k\n", - " if particle[n][\"region\"][event]>=0: #and particle_1[n][\"region\"][event]>=0 and particle_2[n][\"region\"][event]>=0:\n", - " #event = n*batch_size+k\n", - " \n", - " #print(event)\n", - " for i in range(X_grid.shape[0]):\n", - " for j in range(Y_grid.shape[1]):\n", - " \n", - " if X_grid[i,j] < particle[n][\"true_x\"][event]*X_pixels/2 < X_grid[i,j+1]:\n", - " if Y_grid[i,j] < particle[n][\"true_x\"][event]*Y_pixels/2 < Y_grid[i+1,j]:\n", - " \n", - " x_primed=int(Y_pixels/2-Y_grid[i,j])\n", - " y_primed=int(X_pixels/2+X_grid[i,j])\n", - " \n", - " #pics_dict[n][k][x_primed,y_primed,0]=1\n", - " \n", - " pics_dict[n][k][x_primed-1,y_primed-1,0]=particle[n][\"true_ET\"][event]\n", - " #total_pic[x_primed-1,y_primed-1,0]=1\n", - " #total_pic[x_primed-1,y_primed-1,0]=true_events['true_ET'][event]\n", - " \n", - " \n", - " print('Converted '+str(n+1)+'/'+str(n_batches)+' batches of ' +str(batch_size)+' images')\n", - " \n", - " # \n", - " # if N % batch_size != 0:\n", - " # \n", - " # print('Converting last batch of '+str(N%batch_size)+' images') \n", - " # \n", - " # for k in range(batch_size*n_batches,N):\n", - " # #if true_events['region'][k]>=0:\n", - " # \n", - " # for i in range(X_grid.shape[0]):\n", - " # for j in range(Y_grid.shape[1]):\n", - " # if X_grid[i,j-1] < X_norm[n_batches][k]*X_pixels/2 < X_grid[i,j]:\n", - " # if Y_grid[i-1,j] < Y_norm[n_batches][k]*Y_pixels/2 < Y_grid[i,j]:\n", - " # \n", - " # x_primed=int(Y_pixels/2-Y_grid[i,j])\n", - " # y_primed=int(X_pixels/2+X_grid[i,j])\n", - " # \n", - " # pics_dict[n_batches][k-(N-1)][x_primed,y_primed,0]=true_events['true_ET'][event]\n", - " # #total_pic[x_primed,y_primed,0]=true_events['true_ET'][event]\n", - " return pics_dict" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Converted 1/2 batches of 25000 images\n", - "Converted 2/2 batches of 25000 images\n" - ] - } - ], - "source": [ - "pics_dict_piplus = make_pics_dict(X_grid, Y_grid, piplus_norm, n_batches)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Converted 1/2 batches of 25000 images\n", - "Converted 2/2 batches of 25000 images\n" - ] - } - ], - "source": [ - "pics_dict_piplus0 = make_pics_dict(X_grid, Y_grid, piplus0_norm, n_batches)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Converted 1/2 batches of 25000 images\n", - "Converted 2/2 batches of 25000 images\n" - ] - } - ], - "source": [ - "pics_dict_Kminus = make_pics_dict(X_grid, Y_grid, Kminus_norm, n_batches)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(25000, 52, 64, 1)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pics_dict_piplus[1].shape" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -327,25 +144,12 @@ } ], "source": [ - "i=1\n", - "plt.imshow(pics_dict_piplus[1][i].reshape(52,64)+pics_dict_piplus0[1][i].reshape(52,64)+pics_dict_Kminus[0][i].reshape(52,64))\n" + "plt.imshow(pics_dict[0][11].reshape(52,64))" ] }, { "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "pics_dict={}\n", - "\n", - "pics_dict[0]=pics_dict_piplus[0]+pics_dict_piplus0[0]+pics_dict_Kminus[0]\n", - "pics_dict[1]=pics_dict_piplus[1]+pics_dict_piplus0[1]+pics_dict_Kminus[1]" - ] - }, - { - "cell_type": "code", - "execution_count": 24, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -356,21 +160,12 @@ }, { "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "a=np.array([pics_dict_Kminus[0][i].sum()+pics_dict_piplus[0][i].sum()+pics_dict_piplus0[0][i].sum() for i in range(len(pics_dict_Kminus[0]))])" - ] - }, - { - "cell_type": "code", - "execution_count": 31, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -382,27 +177,79 @@ } ], "source": [ - "plt.hist(a/1000,bins=70);" + "plt.hist(pics_dict[0].sum(axis=(1,2))/1000, range=(0,300),bins=70);" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 10, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'r' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTBrowser\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'r' is not defined" - ] - } - ], - "source": [] + "outputs": [], + "source": [ + "#def make_pics_dict(X_grid, Y_grid, tracks, n_batches=n_batches):\n", + "# X_pixels=64\n", + "# Y_pixels=np.int(np.ceil((X_pixels*width_Y)/width_X))\n", + "# pic = np.zeros(shape=(Y_pixels,X_pixels,1),dtype=np.float32)\n", + "# pics_dict = {}\n", + "# \n", + "# for n in range(1):\n", + "# \n", + "# batch_size = tracks['regions'][0].shape[0]\n", + "# pics_dict[n]=np.array([pic for i in range(0,batch_size)])\n", + "# \n", + "# for k in range(batch_size):\n", + "# event=k\n", + "# if tracks['regions'][n][event][0]>=0: #and particle_1[n][\"region\"][event]>=0 and particle_2[n][\"region\"][event]>=0:\n", + "# #event = n*batch_size+k\n", + "# \n", + "# #print(event)\n", + "# for i in range(X_grid.shape[0]-1):\n", + "# for j in range(Y_grid.shape[1]-1):\n", + "# for ntrack in range(tracks['xProjections'][n][event][0].shape[0]):\n", + "# \n", + "# xtrack = tracks['xProjections'][n][event][0][ntrack]*X_pixels/2\n", + "# ytrack = tracks['yProjections'][n][event][0][ntrack]*Y_pixels/2 \n", + "# \n", + "# if X_grid[i,j] < xtrack < X_grid[i,j+1]:\n", + "# if Y_grid[i,j] < ytrack < Y_grid[i+1,j]:\n", + "#\n", + "# \n", + "# x_primed=int(Y_pixels/2-Y_grid[i,j])\n", + "# y_primed=int(X_pixels/2+X_grid[i,j])\n", + "#\n", + "# #pics_dict[n][k][x_primed,y_primed,0]=1\n", + "# \n", + "# pics_dict[n][k][x_primed-1,y_primed-1,0]=tracks[\"realETs\"][n][event][0][ntrack]\n", + "# #total_pic[x_primed-1,y_primed-1,0]=1\n", + "# #total_pic[x_primed-1,y_primed-1,0]=true_events['true_ET'][event]\n", + "# \n", + "# \n", + "# print('Converted '+str(n+1)+'/'+str(n_batches)+' batches of ' +str(batch_size)+' images')\n", + "# \n", + "# # \n", + "# # if N % batch_size != 0:\n", + "# # \n", + "# # print('Converting last batch of '+str(N%batch_size)+' images') \n", + "# # \n", + "# # for k in range(batch_size*n_batches,N):\n", + "# # #if true_events['region'][k]>=0:\n", + "# # \n", + "# # for i in range(X_grid.shape[0]):\n", + "# # for j in range(Y_grid.shape[1]):\n", + "# # if X_grid[i,j-1] < X_norm[n_batches][k]*X_pixels/2 < X_grid[i,j]:\n", + "# # if Y_grid[i-1,j] < Y_norm[n_batches][k]*Y_pixels/2 < Y_grid[i,j]:\n", + "# # \n", + "# # x_primed=int(Y_pixels/2-Y_grid[i,j])\n", + "# # y_primed=int(X_pixels/2+X_grid[i,j])\n", + "# # \n", + "# # pics_dict[n_batches][k-(N-1)][x_primed,y_primed,0]=true_events['true_ET'][event]\n", + "# # #total_pic[x_primed,y_primed,0]=true_events['true_ET'][event]\n", + "# return pics_dict\n", + "#\n", + "#\n", + "#\n", + "#" + ] }, { "cell_type": "code", diff --git a/true_root_to_df_DKpi.ipynb b/true_root_to_df_DKpi.ipynb index 8e21448..5e7668a 100644 --- a/true_root_to_df_DKpi.ipynb +++ b/true_root_to_df_DKpi.ipynb @@ -25,58 +25,15 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "file_name='DplusMuNu_Full'\n", + "\n", + "file_name='B2Dmunu_full'\n", "file_path='/disk/lhcb_data/davide/HCAL_project_full_event/'+file_name+'.root'\n", - "tree_name='ntuple/DecayTree'" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "f = r.TFile(file_path)\n", - "t = f.Get(tree_name)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def get_tracker_info(particle):\n", - " \n", - " t.SetBranchStatus(\"*\",0)\n", - " \n", - " t.SetBranchStatus(particle+\"_L0Calo_HCAL_xProjection\",1)\n", - " t.SetBranchStatus(particle+\"_L0Calo_HCAL_yProjection\",1)\n", - " t.SetBranchStatus(particle+\"_L0Calo_HCAL_realET\",1)\n", - " t.SetBranchStatus(particle+\"_L0Calo_HCAL_region\", 1)\n", - "\n", - " x_projections=[]\n", - " y_projections=[]\n", - " real_ET=[]\n", - " region=[]\n", - "\n", - " for i, event in enumerate(t):\n", - " \n", - " #if i > 2:\n", - " # break\n", - "\n", - " region.append(getattr(event,particle+\"_L0Calo_HCAL_region\"))\n", - " x_projections.append(getattr(event,particle+\"_L0Calo_HCAL_xProjection\"))\n", - " y_projections.append(getattr(event,particle+\"_L0Calo_HCAL_yProjection\"))\n", - " real_ET.append(getattr(event,particle+\"_L0Calo_HCAL_realET\"))\n", - " \n", - " true_events ={'true_x':np.array(x_projections),'true_y':np.array(y_projections),'true_ET':np.array(real_ET),'region':np.array(region)}\n", - " \n", - " return true_events" + "tree_name='Bd2Dmu/DecayTree'\n", + "\n" ] }, { @@ -85,94 +42,130 @@ "metadata": {}, "outputs": [], "source": [ - "true_events_piplus = get_tracker_info(\"piplus\")\n", - "true_events_piplus0 = get_tracker_info(\"piplus0\")\n", - "true_events_Kminus = get_tracker_info(\"Kminus\")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(465693,)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "true_events_piplus0['region'].shape" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(24401,)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "true_events_piplus0['region'][np.where(true_events_piplus0['region']<0)].shape" + "b=r.TBrowser()" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, + "outputs": [], + "source": [ + "f = r.TFile(file_path)\n", + "t = f.Get(tree_name)\n", + "j=t.GetEntries()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size=20000\n", + "#n_batches=2\n", + "\n", + "N = j\n", + "n_batches= N//batch_size" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "xProjections_dict={}\n", + "particle='pi1'\n", + "\n", + "for j in range(n_batches):\n", + " xProjections_dict[j]=rn.root2array(\n", + " filenames=file_path, \n", + " treename=tree_name,\n", + " branches=[particle+'_L0Calo_HCAL_xProjections'],\n", + " start=j*batch_size,\n", + " stop=(j+1)*batch_size,\n", + " )\n", + " \n", + "yProjections_dict={}\n", + "particle='pi1'\n", + "\n", + "for j in range(n_batches):\n", + " yProjections_dict[j]=rn.root2array(\n", + " filenames=file_path, \n", + " treename=tree_name,\n", + " branches=[particle+'_L0Calo_HCAL_yProjections'],\n", + " start=j*batch_size,\n", + " stop=(j+1)*batch_size,\n", + " )\n", + " \n", + "realETs_dict={}\n", + "particle='pi1'\n", + "\n", + "for j in range(n_batches):\n", + " realETs_dict[j]=rn.root2array(\n", + " filenames=file_path, \n", + " treename=tree_name,\n", + " branches=[particle+'_L0Calo_HCAL_realETs'],\n", + " start=j*batch_size,\n", + " stop=(j+1)*batch_size,\n", + " )\n", + " \n", + "regions_dict={}\n", + "particle='pi1'\n", + "\n", + "for j in range(n_batches):\n", + " regions_dict[j]=rn.root2array(\n", + " filenames=file_path, \n", + " treename=tree_name,\n", + " branches=[particle+'_L0Calo_HCAL_region'],\n", + " start=j*batch_size,\n", + " stop=(j+1)*batch_size,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "true_events={\n", + " 'xProjections':xProjections_dict, \n", + " 'yProjections':yProjections_dict, \n", + " 'realETs':realETs_dict,\n", + " 'regions':regions_dict,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(1131.9902543165215, 507.3645231436275, 1)" + "11" ] }, - "execution_count": 10, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "true_events_Kminus['true_x'][0],true_events_Kminus['true_y'][0],true_events_Kminus['region'][0]" + "len(true_events['xProjections'])" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ - "df = pd.DataFrame.from_dict(true_events_piplus)\n", - "df.to_csv('/disk/lhcb_data/davide/HCAL_project_full_event/csv/piplus/MCtrue_piplus.csv', index=False)\n", - "\n", - "df = pd.DataFrame.from_dict(true_events_piplus0)\n", - "df.to_csv('/disk/lhcb_data/davide/HCAL_project_full_event/csv/piplus0/MCtrue_piplus0.csv', index=False)\n", - "\n", - "df = pd.DataFrame.from_dict(true_events_Kminus)\n", - "df.to_csv('/disk/lhcb_data/davide/HCAL_project_full_event/csv/Kminus/MCtrue_Kminus.csv', index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "b = r.TBrowser()" + "with open('/disk/lhcb_data/davide/HCAL_project_full_event/csv/MCtracker_info.pickle', 'wb') as f:\n", + " pickle.dump(true_events, f)\n" ] }, {