You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

381 lines
14 KiB

9 months ago
  1. {
  2. "cells": [
  3. {
  4. "cell_type": "code",
  5. "execution_count": null,
  6. "metadata": {},
  7. "outputs": [],
  8. "source": [
  9. "import uproot\t\n",
  10. "import numpy as np\n",
  11. "import matplotlib.pyplot as plt\n",
  12. "from mpl_toolkits import mplot3d\n",
  13. "import awkward as ak\n",
  14. "from scipy.optimize import curve_fit\n",
  15. "%matplotlib inline"
  16. ]
  17. },
  18. {
  19. "cell_type": "code",
  20. "execution_count": null,
  21. "metadata": {},
  22. "outputs": [],
  23. "source": [
  24. "\"\"\"\n",
  25. "# found\n",
  26. "\n",
  27. "brem_e = electrons[\"brem_photons_pe\"]\n",
  28. "brem_z = electrons[\"brem_vtx_z\"]\n",
  29. "brem_x = electrons[\"brem_vtx_x\"]\n",
  30. "e = electrons[\"energy\"]\n",
  31. "length = electrons[\"brem_vtx_z_length\"]\n",
  32. "\n",
  33. "\n",
  34. "\n",
  35. "brem_f = ak.ArrayBuilder()\n",
  36. "\n",
  37. "for itr in range(ak.num(found, axis=0)):\n",
  38. " brem_f.begin_record()\n",
  39. " brem_f.field(\"lost\").boolean()\n",
  40. " # [:,\"energy\"] energy\n",
  41. " brem_f.field(\"energy\").append(e_f[itr])\n",
  42. " # [:,\"photon_length\"] number of vertices\n",
  43. " brem_f.field(\"photon_length\").integer(length_f[itr])\n",
  44. " # [:,\"brem_photons_pe\",:] photon energy\n",
  45. " brem_f.field(\"brem_photons_pe\").append(brem_e_f[itr])\n",
  46. " # [:,\"brem_vtx_z\",:] brem vtx z\n",
  47. " brem_f.field(\"brem_vtx_x\").append(brem_x_f[itr])\n",
  48. " brem_f.field(\"brem_vtx_z\").append(brem_z_f[itr])\n",
  49. " brem_f.end_record()\n",
  50. "\n",
  51. "brem_f = ak.Array(brem_f)\n",
  52. "\n",
  53. "# lost\n",
  54. "\n",
  55. "brem_e_l = lost[\"brem_photons_pe\"]\n",
  56. "brem_z_l = lost[\"brem_vtx_z\"]\n",
  57. "brem_x_l = lost[\"brem_vtx_x\"]\n",
  58. "e_l = lost[\"energy\"]\n",
  59. "length_l = lost[\"brem_vtx_z_length\"]\n",
  60. "\n",
  61. "brem_l = ak.ArrayBuilder()\n",
  62. "\n",
  63. "for itr in range(ak.num(lost, axis=0)):\n",
  64. " brem_l.begin_record()\n",
  65. " # [:,\"energy\"] energy\n",
  66. " brem_l.field(\"energy\").append(e_l[itr])\n",
  67. " # [:,\"photon_length\"] number of vertices\n",
  68. " brem_l.field(\"photon_length\").integer(length_l[itr])\n",
  69. " # [:,\"brem_photons_pe\",:] photon energy\n",
  70. " brem_l.field(\"brem_photons_pe\").append(brem_e_l[itr])\n",
  71. " # [:,\"brem_vtx_z\",:] brem vtx z\n",
  72. " brem_l.field(\"brem_vtx_x\").append(brem_x_l[itr])\n",
  73. " brem_l.field(\"brem_vtx_z\").append(brem_z_l[itr])\n",
  74. " brem_l.end_record()\n",
  75. "\n",
  76. "brem_l = ak.Array(brem_l)\n",
  77. "\"\"\""
  78. ]
  79. },
  80. {
  81. "cell_type": "code",
  82. "execution_count": null,
  83. "metadata": {},
  84. "outputs": [],
  85. "source": [
  86. "\"\"\"\n",
  87. "photon_cut = 0\n",
  88. "photon_cut_ratio = 0.2\n",
  89. "\n",
  90. "cut_brem_found = ak.ArrayBuilder()\n",
  91. "\n",
  92. "for itr in range(ak.num(brem_f, axis=0)):\n",
  93. " cut_brem_found.begin_record()\n",
  94. " cut_brem_found.field(\"energy\").real(brem_f[itr, \"energy\"])\n",
  95. "\n",
  96. " tmp_energy = brem_f[itr, \"energy\"]\n",
  97. "\n",
  98. " cut_brem_found.field(\"brem_photons_pe\")\n",
  99. " cut_brem_found.begin_list()\n",
  100. " for jentry in range(brem_f[itr, \"photon_length\"]):\n",
  101. " if (\n",
  102. " brem_f[itr, \"brem_vtx_z\", jentry] > 5000\n",
  103. " or brem_f[itr, \"brem_photons_pe\", jentry] < photon_cut\n",
  104. " or brem_f[itr, \"brem_photons_pe\", jentry] < photon_cut_ratio * tmp_energy\n",
  105. " ):\n",
  106. " continue\n",
  107. " else:\n",
  108. " cut_brem_found.real(brem_f[itr, \"brem_photons_pe\", jentry])\n",
  109. " tmp_energy -= brem_f[itr, \"brem_photons_pe\", jentry]\n",
  110. " cut_brem_found.end_list()\n",
  111. "\n",
  112. " tmp_energy = brem_f[itr, \"energy\"]\n",
  113. "\n",
  114. " cut_brem_found.field(\"brem_vtx_x\")\n",
  115. " cut_brem_found.begin_list()\n",
  116. " for jentry in range(brem_f[itr, \"photon_length\"]):\n",
  117. " if (\n",
  118. " brem_f[itr, \"brem_vtx_z\", jentry] > 5000\n",
  119. " or brem_f[itr, \"brem_photons_pe\", jentry] < photon_cut\n",
  120. " or brem_f[itr, \"brem_photons_pe\", jentry] < photon_cut_ratio * tmp_energy\n",
  121. " ):\n",
  122. " continue\n",
  123. " else:\n",
  124. " cut_brem_found.real(brem_f[itr, \"brem_vtx_x\", jentry])\n",
  125. " tmp_energy -= brem_f[itr, \"brem_photons_pe\", jentry]\n",
  126. " cut_brem_found.end_list()\n",
  127. "\n",
  128. " tmp_energy = brem_f[itr, \"energy\"]\n",
  129. "\n",
  130. " cut_brem_found.field(\"brem_vtx_z\")\n",
  131. " cut_brem_found.begin_list()\n",
  132. " for jentry in range(brem_f[itr, \"photon_length\"]):\n",
  133. " if (\n",
  134. " brem_f[itr, \"brem_vtx_z\", jentry] > 5000\n",
  135. " or brem_f[itr, \"brem_photons_pe\", jentry] < photon_cut\n",
  136. " or brem_f[itr, \"brem_photons_pe\", jentry] < photon_cut_ratio * tmp_energy\n",
  137. " ):\n",
  138. " continue\n",
  139. " else:\n",
  140. " cut_brem_found.real(brem_f[itr, \"brem_vtx_z\", jentry])\n",
  141. " tmp_energy -= brem_f[itr, \"brem_photons_pe\", jentry]\n",
  142. " cut_brem_found.end_list()\n",
  143. "\n",
  144. " cut_brem_found.end_record()\n",
  145. "\n",
  146. "tuple_found = ak.Array(cut_brem_found)\n",
  147. "\n",
  148. "cut_brem_lost = ak.ArrayBuilder()\n",
  149. "\n",
  150. "for itr in range(ak.num(brem_l, axis=0)):\n",
  151. " cut_brem_lost.begin_record()\n",
  152. " cut_brem_lost.field(\"energy\").real(brem_l[itr, \"energy\"])\n",
  153. "\n",
  154. " tmp_energy = brem_l[itr, \"energy\"]\n",
  155. "\n",
  156. " cut_brem_lost.field(\"brem_photons_pe\")\n",
  157. " cut_brem_lost.begin_list()\n",
  158. " for jentry in range(brem_l[itr, \"photon_length\"]):\n",
  159. " if (\n",
  160. " brem_l[itr, \"brem_vtx_z\", jentry] > 5000\n",
  161. " or brem_l[itr, \"brem_photons_pe\", jentry] < photon_cut\n",
  162. " or brem_l[itr, \"brem_photons_pe\", jentry] < photon_cut_ratio * tmp_energy\n",
  163. " ):\n",
  164. " continue\n",
  165. " else:\n",
  166. " cut_brem_lost.real(brem_l[itr, \"brem_photons_pe\", jentry])\n",
  167. " tmp_energy -= brem_l[itr, \"brem_photons_pe\", jentry]\n",
  168. " cut_brem_lost.end_list()\n",
  169. "\n",
  170. " tmp_energy = brem_l[itr, \"energy\"]\n",
  171. "\n",
  172. " cut_brem_lost.field(\"brem_vtx_x\")\n",
  173. " cut_brem_lost.begin_list()\n",
  174. " for jentry in range(brem_l[itr, \"photon_length\"]):\n",
  175. " if (\n",
  176. " brem_l[itr, \"brem_vtx_z\", jentry] > 5000\n",
  177. " or brem_l[itr, \"brem_photons_pe\", jentry] < photon_cut\n",
  178. " or brem_l[itr, \"brem_photons_pe\", jentry] < photon_cut_ratio * tmp_energy\n",
  179. " ):\n",
  180. " continue\n",
  181. " else:\n",
  182. " cut_brem_lost.real(brem_l[itr, \"brem_vtx_x\", jentry])\n",
  183. " tmp_energy -= brem_l[itr, \"brem_photons_pe\", jentry]\n",
  184. " cut_brem_lost.end_list()\n",
  185. "\n",
  186. " tmp_energy = brem_l[itr, \"energy\"]\n",
  187. "\n",
  188. " cut_brem_lost.field(\"brem_vtx_z\")\n",
  189. " cut_brem_lost.begin_list()\n",
  190. " for jentry in range(brem_l[itr, \"photon_length\"]):\n",
  191. " if (\n",
  192. " brem_l[itr, \"brem_vtx_z\", jentry] > 5000\n",
  193. " or brem_l[itr, \"brem_photons_pe\", jentry] < photon_cut\n",
  194. " or brem_l[itr, \"brem_photons_pe\", jentry] < photon_cut_ratio * tmp_energy\n",
  195. " ):\n",
  196. " continue\n",
  197. " else:\n",
  198. " cut_brem_lost.real(brem_l[itr, \"brem_vtx_z\", jentry])\n",
  199. " tmp_energy -= brem_l[itr, \"brem_photons_pe\", jentry]\n",
  200. " cut_brem_lost.end_list()\n",
  201. "\n",
  202. " cut_brem_lost.end_record()\n",
  203. "\n",
  204. "tuple_lost = ak.Array(cut_brem_lost)\n",
  205. "\"\"\""
  206. ]
  207. },
  208. {
  209. "cell_type": "code",
  210. "execution_count": null,
  211. "metadata": {},
  212. "outputs": [],
  213. "source": [
  214. "electrons_lost = ak.ArrayBuilder()\n",
  215. "\n",
  216. "for jelec in range(ak.num(tuple_lost, axis=0)):\n",
  217. " electrons_lost.begin_record()\n",
  218. " electrons_lost.field(\"energy\").real(tuple_lost[jelec, \"energy\"])\n",
  219. "\n",
  220. " tmp_velo = 0\n",
  221. " tmp_richut = 0\n",
  222. " for jphoton in range(ak.num(tuple_lost[jelec][\"brem_photons_pe\"], axis=0)):\n",
  223. " if tuple_lost[jelec, \"brem_vtx_z\", jphoton] <= 800:\n",
  224. " tmp_velo += tuple_lost[jelec, \"brem_photons_pe\", jphoton]\n",
  225. " elif (tuple_lost[jelec, \"brem_vtx_z\", jphoton] > 800) and (\n",
  226. " tuple_lost[jelec, \"brem_vtx_z\", jphoton] <= 3000\n",
  227. " ):\n",
  228. " tmp_richut += tuple_lost[jelec, \"brem_photons_pe\", jphoton]\n",
  229. "\n",
  230. " electrons_lost.field(\"velo\").real(tmp_velo)\n",
  231. "\n",
  232. " electrons_lost.field(\"rich\").real(tmp_richut)\n",
  233. " \n",
  234. " if (tmp_velo==0) and (tmp_richut==0):\n",
  235. " electrons_lost.field(\"quality\").integer(0)\n",
  236. " else:\n",
  237. " electrons_lost.field(\"quality\").integer(1)\n",
  238. "\n",
  239. " electrons_lost.end_record()\n",
  240. "\n",
  241. "electrons_lost = ak.Array(electrons_lost)\n",
  242. "\n",
  243. "electrons_found = ak.ArrayBuilder()\n",
  244. "\n",
  245. "for jelec in range(ak.num(tuple_found, axis=0)):\n",
  246. " electrons_found.begin_record()\n",
  247. " electrons_found.field(\"energy\").real(tuple_found[jelec, \"energy\"])\n",
  248. "\n",
  249. " tmp_velo = 0\n",
  250. " tmp_richut = 0\n",
  251. " for jphoton in range(ak.num(tuple_found[jelec][\"brem_photons_pe\"], axis=0)):\n",
  252. " if tuple_found[jelec, \"brem_vtx_z\", jphoton] <= 850:\n",
  253. " tmp_velo += tuple_found[jelec, \"brem_photons_pe\", jphoton]\n",
  254. " elif (tuple_found[jelec, \"brem_vtx_z\", jphoton] > 850) and (\n",
  255. " tuple_found[jelec, \"brem_vtx_z\", jphoton] <= 3000\n",
  256. " ):\n",
  257. " tmp_richut += tuple_found[jelec, \"brem_photons_pe\", jphoton]\n",
  258. "\n",
  259. " electrons_found.field(\"velo\").real(tmp_velo)\n",
  260. "\n",
  261. " electrons_found.field(\"rich\").real(tmp_richut)\n",
  262. " \n",
  263. " if (tmp_velo==0) and (tmp_richut==0):\n",
  264. " electrons_found.field(\"quality\").integer(0)\n",
  265. " else:\n",
  266. " electrons_found.field(\"quality\").integer(1)\n",
  267. "\n",
  268. " electrons_found.end_record()\n",
  269. "\n",
  270. "electrons_found = ak.Array(electrons_found)"
  271. ]
  272. },
  273. {
  274. "cell_type": "code",
  275. "execution_count": null,
  276. "metadata": {},
  277. "outputs": [],
  278. "source": [
  279. "\n",
  280. "def ratio(nominator, denom):\n",
  281. " denominator = ak.num(denom[\"energy\"], axis=0)\n",
  282. " return nominator / denominator\n",
  283. "\n",
  284. "\n",
  285. "def eff(found, lost):\n",
  286. " return found / (found + lost)"
  287. ]
  288. },
  289. {
  290. "cell_type": "code",
  291. "execution_count": null,
  292. "metadata": {},
  293. "outputs": [],
  294. "source": [
  295. "n_elec_lost = ak.num(tuple_lost, axis=0)\n",
  296. "\n",
  297. "velo_lost = 0\n",
  298. "\n",
  299. "richut_lost = 0\n",
  300. "\n",
  301. "for jelec in range(ak.num(tuple_lost, axis=0)):\n",
  302. " veloemitted = False\n",
  303. " richemitted = False\n",
  304. " for jphoton in range(ak.num(tuple_lost[jelec][\"brem_photons_pe\"], axis=0)):\n",
  305. " if (tuple_lost[jelec, \"brem_vtx_z\", jphoton] <= 770) and (veloemitted == False):\n",
  306. " velo_lost += 1\n",
  307. " veloemitted = True\n",
  308. " elif (\n",
  309. " (tuple_lost[jelec, \"brem_vtx_z\", jphoton] > 770)\n",
  310. " and (tuple_lost[jelec, \"brem_vtx_z\", jphoton] <= 3000)\n",
  311. " and (richemitted == False)\n",
  312. " ):\n",
  313. " richut_lost += 1\n",
  314. " richemitted = True\n",
  315. "\n",
  316. "print(\"ratio of lost electrons emitting in Velo: \", ratio(velo_lost, brem[brem.lost]))\n",
  317. "print(\"ratio of lost electrons emitting in Rich1+UT: \", ratio(richut_lost, brem[brem.lost]))"
  318. ]
  319. },
  320. {
  321. "cell_type": "code",
  322. "execution_count": null,
  323. "metadata": {},
  324. "outputs": [],
  325. "source": [
  326. "# efficiency berechnen als found in velo oder rich über alle elektronen\n",
  327. "# dann kann man zusammenrechnen mit velo, rich, und allen anderen elektronen\n",
  328. "\n",
  329. "num_velo_found = 0\n",
  330. "num_rich_found = 0\n",
  331. "for itr in range(ak.num(electrons_found, axis=0)):\n",
  332. " if (electrons_found[itr, \"quality\"]==1):\n",
  333. " if (electrons_found[itr, \"velo\"] >= electrons_found[itr, \"rich\"]):\n",
  334. " num_velo_found += 1\n",
  335. " else:\n",
  336. " num_rich_found += 1\n",
  337. "\n",
  338. "num_velo_lost = 0\n",
  339. "num_rich_lost = 0\n",
  340. "for itr in range(ak.num(electrons_lost, axis=0)):\n",
  341. " if (electrons_lost[itr, \"quality\"]==1):\n",
  342. " if electrons_lost[itr, \"velo\"] >= electrons_lost[itr, \"rich\"]:\n",
  343. " num_velo_lost += 1\n",
  344. " else:\n",
  345. " num_rich_lost += 1\n",
  346. "\n",
  347. "lost_elec = ak.num(electrons[electrons.lost],axis=0)\n",
  348. "found_elec = ak.num(electrons[~(electrons.lost)],axis=0)\n",
  349. "denom = lost_elec+found_elec\n",
  350. "\n",
  351. "eff_velo = num_velo_found/denom\n",
  352. "\n",
  353. "eff_rich = num_rich_found/denom\n",
  354. "\n",
  355. "eff_other = ak.num(electrons_found[electrons_found[\"quality\"]==0],axis=0)/denom\n",
  356. "\n",
  357. "print(\"VELO energy emission, eff: \", eff_velo)\n",
  358. "\n",
  359. "print(\"RICH1+UT energy emission, eff: \", eff_rich)\n",
  360. "\n",
  361. "print(\"Neither, eff: \", eff_other)\n",
  362. "\n",
  363. "print(\"total efficiency: \", eff_velo + eff_rich + eff_other)"
  364. ]
  365. },
  366. {
  367. "cell_type": "code",
  368. "execution_count": null,
  369. "metadata": {},
  370. "outputs": [],
  371. "source": []
  372. }
  373. ],
  374. "metadata": {
  375. "language_info": {
  376. "name": "python"
  377. }
  378. },
  379. "nbformat": 4,
  380. "nbformat_minor": 2
  381. }