diff --git a/notebooks/ePix100/Characterize_Darks_ePix100_NBC.ipynb b/notebooks/ePix100/Characterize_Darks_ePix100_NBC.ipynb
index a1e0069c8afa24a682f42a47ae6312b6987bc0fb..8f98c1dae60d76c7bda930cc399d5133e22a77ee 100644
--- a/notebooks/ePix100/Characterize_Darks_ePix100_NBC.ipynb
+++ b/notebooks/ePix100/Characterize_Darks_ePix100_NBC.ipynb
@@ -2,16 +2,17 @@
"cells": [
{
"cell_type": "markdown",
- "metadata": {},
+ "metadata": {
+ "tags": []
+ },
"source": [
- "Updated version of the ePix100 Dark Characterization notebook:\n",
- "\n",
- "- Generates the bad pixel map.\n",
- "- Added badpixel_threshold_sigma input variable: Number of standard deviations considered for bad pixel classification.\n",
- "- Sensor size is read from hdf5 file instead of being manually input.\n",
- "- Detector temperature can be read from hdf5 file instead of having a fixed value only.\n",
- "- Removed the xcal.HistogramCalculator() function, which calculation output was not in use.\n",
- "- Set db_module to \"\" by default in the first cell (TODO note of previous notebook version)."
+ "# ePix100 Dark Characterization\n",
+ "\n",
+ "Author: European XFEL Detector Group, Version: 2.0\n",
+ "\n",
+ "The following notebook provides dark image analysis and calibration constants of the ePix100 detector.\n",
+ "\n",
+ "Dark characterization evaluates offset and noise of the detector and gives information about bad pixels. Resulting maps are saved as .h5 files for a latter use and injected to calibration DB."
]
},
{
@@ -20,14 +21,14 @@
"metadata": {},
"outputs": [],
"source": [
- "in_folder = '/gpfs/exfel/exp/HED/202030/p900136/raw' # input folder, required\n",
+ "in_folder = '/gpfs/exfel/exp/HED/202230/p900247/raw' # input folder, required\n",
"out_folder = '' # output folder, required\n",
"sequence = 0 # sequence file to use\n",
- "run = 182 # which run to read data from, required\n",
+ "run = 45 # which run to read data from, required\n",
"\n",
"# Parameters for accessing the raw data.\n",
- "karabo_id = \"HED_IA1_EPX100-2\" # karabo karabo_id\n",
- "karabo_da = [\"EPIX02\"] # data aggregators\n",
+ "karabo_id = \"HED_IA1_EPX100-1\" # karabo karabo_id\n",
+ "karabo_da = [\"EPIX01\"] # data aggregators\n",
"receiver_template = \"RECEIVER\" # detector receiver template for accessing raw data files\n",
"path_template = 'RAW-R{:04d}-{}-S{{:05d}}.h5' # the template to use to access data\n",
"instrument_source_template = '{}/DET/{}:daqOutput' # instrument detector data source in h5files\n",
@@ -39,9 +40,12 @@
"db_output = False # Output constants to the calibration database\n",
"local_output = True # output constants locally\n",
"\n",
- "badpixel_threshold_sigma = 5. # bad pixels defined by values outside n times this std from median\n",
- "number_dark_frames = 0 # number of images to be used, if set to 0 all available images are used\n",
+ "# Conditions used for injected calibration constants.\n",
+ "bias_voltage = 200 # bias voltage\n",
+ "in_vacuum = False # detector operated in vacuum\n",
+ "fix_temperature = 0. # Fixed temperature in Kelvin. Set to 0 to read from .h5 file\n",
"temp_limits = 5 # limit for parameter Operational temperature\n",
+ "badpixel_threshold_sigma = 5. # bad pixels defined by values outside n times this std from median\n",
"\n",
"# Parameters used during selecting raw data trains.\n",
"min_trains = 1 # Minimum number of trains that should be available to process dark constants. Default 1.\n",
@@ -69,7 +73,9 @@
"\n",
"import XFELDetAna.xfelprofiler as xprof\n",
"from XFELDetAna import xfelpyanatools as xana\n",
+ "from XFELDetAna.detectors.fastccd import readerh5 as fastccdreaderh5\n",
"from XFELDetAna.plotting.util import prettyPlotting\n",
+ "from cal_tools.enums import BadPixels\n",
"from cal_tools.tools import (\n",
" get_dir_creation_date,\n",
" get_pdu_from_db,\n",
@@ -108,12 +114,11 @@
"# Read report path and create file location tuple to add with the injection\n",
"proposal = list(filter(None, in_folder.strip('/').split('/')))[-2]\n",
"file_loc = f'proposal:{proposal} runs:{run}'\n",
- "pixels_x = 708\n",
- "pixels_y = 768\n",
"report = get_report(out_folder)\n",
"\n",
"ped_dir = os.path.join(in_folder, f\"r{run:04d}\")\n",
"fp_name = path_template.format(run, karabo_da[0]).format(sequence)\n",
+ "filename = os.path.join(ped_dir, fp_name)\n",
"run_dir = RunDirectory(ped_dir)\n",
"\n",
"print(f\"Run number: {run}\")\n",
@@ -130,10 +135,16 @@
"metadata": {},
"outputs": [],
"source": [
- "pixel_data = (instrument_src, \"data.image.pixels\")\n",
+ "# Read sensor size\n",
+ "sensor_size = np.array(run_dir.get_array( \n",
+ " instrument_src,\n",
+ " \"data.image.dims\")[0,:2]) # (x,y)\n",
+ "\n",
+ "# Path to pixel ADC values\n",
+ "pixel_data_dir = (instrument_src, \"data.image.pixels\")\n",
"\n",
"# Specifies total number of images to proceed\n",
- "n_trains = run_dir.get_data_counts(*pixel_data).shape[0]\n",
+ "n_trains = run_dir.get_data_counts(*pixel_data_dir).shape[0]\n",
"\n",
"# Modify n_trains to process based on given maximum\n",
"# and minimun number of trains.\n",
@@ -145,25 +156,26 @@
" f\"Less than {min_trains} trains are available in RAW data.\"\n",
" \" Not enough data to process darks.\")\n",
"\n",
- "print(f\"Number of dark images to analyze: {n_trains}.\")\n",
+ "print(f\"Number of dark images to analyze: {n_trains}\")\n",
"\n",
"integration_time = int(run_dir.get_array(\n",
" f\"{karabo_id}/DET/CONTROL\",\n",
" \"expTime.value\")[0])\n",
- "temperature = np.mean(run_dir.get_array(\n",
- " instrument_src,\n",
- " \"data.backTemp\").values) / 100.\n",
"\n",
- "if fix_temperature != 0:\n",
+ "if fix_temperature:\n",
" temperature_k = fix_temperature\n",
+ " temperature = fix_temperature - 273.15\n",
" print(\"Temperature is fixed!\")\n",
"else:\n",
+ " temperature = np.mean(run_dir.get_array(\n",
+ " instrument_src,\n",
+ " \"data.backTemp\").values) / 100.\n",
" temperature_k = temperature + 273.15\n",
"\n",
"print(f\"Bias voltage is {bias_voltage} V\")\n",
- "print(f\"Detector integration time is set to {integration_time}\")\n",
- "print(f\"Mean temperature was {temperature:0.2f} °C / {temperature_k:0.2f} K\")\n",
- "print(f\"Operated in vacuum: {in_vacuum} \")"
+ "print(f\"Detector integration time is set to {integration_time} \\u03BCs\")\n",
+ "print(f\"Mean temperature was {temperature:0.1f}°C / {temperature_k:0.1f} K\")\n",
+ "print(f\"Operated in vacuum: {in_vacuum}\")"
]
},
{
@@ -174,14 +186,28 @@
},
"outputs": [],
"source": [
+ "# Calculate noise and offset per pixel and global average, std and median\n",
"data_dc = run_dir.select(\n",
- " *pixel_data, require_all=True).select_trains(np.s_[:n_trains])\n",
+ " *pixel_data_dir, require_all=True).select_trains(np.s_[:n_trains])\n",
"print(f\"Reading data from: {data_dc.files}\\n\")\n",
"\n",
- "data = data_dc[pixel_data].ndarray()\n",
+ "data = data_dc[pixel_data_dir].ndarray()\n",
"\n",
"noise_data = np.std(data, axis=0)\n",
- "offset_data = np.mean(data, axis=0)"
+ "offset_data = np.mean(data, axis=0)\n",
+ "\n",
+ "noise_mean = np.mean(noise_data)\n",
+ "noise_sigma = np.std(noise_data)\n",
+ "noise_median = np.median(noise_data)\n",
+ "noise_min = np.min(noise_data)\n",
+ "noise_max = np.max(noise_data)\n",
+ "\n",
+ "\n",
+ "offset_mean = np.mean(offset_data)\n",
+ "offset_sigma = np.std(offset_data)\n",
+ "offset_median = np.median(offset_data)\n",
+ "offset_min = np.min(offset_data)\n",
+ "offset_max = np.max(offset_data)"
]
},
{
@@ -190,94 +216,111 @@
"metadata": {},
"outputs": [],
"source": [
+ "# Create and fill offset and noise maps\n",
"constant_maps = {}\n",
"constant_maps['Offset'] = offset_data[..., np.newaxis]\n",
- "constant_maps['Noise'] = noise_data[..., np.newaxis]\n",
- "print(\"Initial constant maps are created\")"
+ "constant_maps['Noise'] = noise_data[..., np.newaxis]"
]
},
{
- "cell_type": "code",
- "execution_count": null,
+ "cell_type": "markdown",
"metadata": {},
- "outputs": [],
"source": [
- "noise_mean = np.mean(constant_maps['Noise'].data.flatten())\n",
- "noise_sigma = np.std(constant_maps['Noise'].data.flatten())\n",
- "noise_median = np.median(constant_maps['Noise'].data.flatten())\n",
- "\n",
- "offset_mean = np.mean(constant_maps['Offset'].data.flatten())\n",
- "offset_sigma = np.std(constant_maps['Offset'].data.flatten())\n",
- "offset_median = np.median(constant_maps['Offset'].data.flatten())"
+ "## Offset ###"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "87b73246-9080-4303-adbd-d8708886e775",
"metadata": {},
"outputs": [],
"source": [
"#************** OFFSET HEAT MAP **************#\n",
- "plt.figure(1)\n",
- "fig1 = xana.heatmapPlot(constant_maps['Offset'][:, :, 0].data,\n",
- " lut_label='[ADU]',\n",
- " x_label = 'Column',\n",
- " y_label = 'Row',\n",
- " x_range=(0, sensorSize[1]),\n",
- " y_range=(0, sensorSize[0]), \n",
- " vmin=max(0,offset_median - badpixel_threshold_sigma*offset_sigma), \n",
- " vmax=min(np.power(2,14)-1,offset_median + badpixel_threshold_sigma*offset_sigma))\n",
- "\n",
- "fig1.suptitle('Offset Map',x=.48,y=.9,fontsize=16)\n",
- "fig1.set_size_inches(h=15,w=15)\n",
+ "fig = xana.heatmapPlot(\n",
+ " constant_maps['Offset'][:, :, 0],\n",
+ " lut_label='[ADU]',\n",
+ " x_label = 'Column',\n",
+ " y_label = 'Row',\n",
+ " x_range = (0, sensor_size[0]),\n",
+ " y_range = (0, sensor_size[1]), \n",
+ " vmin = max(0, offset_median - badpixel_threshold_sigma*offset_sigma), \n",
+ " vmax = min(np.power(2,14)-1, offset_median + badpixel_threshold_sigma*offset_sigma)\n",
+ ")\n",
+ "fig.suptitle('Offset Map', x=.48, y=.9, fontsize=16)\n",
+ "fig.set_size_inches(h=15, w=15)\n",
"\n",
"#************** OFFSET HISTOGRAM **************#\n",
"binwidth = offset_sigma/100\n",
- "ho, co = np.histogram(constant_maps['Offset'].data.flatten(),\n",
- " bins=np.arange((min(constant_maps['Offset'].data.flatten())),\n",
- " max(constant_maps['Offset'].data.flatten()) + binwidth,\n",
- " binwidth))\n",
+ "ho, co = np.histogram(\n",
+ " constant_maps['Offset'].flatten(),\n",
+ " bins = np.arange(offset_min, offset_max, binwidth)\n",
+ ")\n",
"do = {'x': co[:-1],\n",
" 'y': ho,\n",
" 'y_err': np.sqrt(ho[:]),\n",
" 'drawstyle': 'bars',\n",
" 'color': 'cornflowerblue'}\n",
"\n",
- "fig2 = xana.simplePlot(do, \n",
- " aspect=1.5,\n",
- " x_label='Offset [ADU]',\n",
- " y_label='Counts',\n",
- " x_range=(max(0,offset_median - badpixel_threshold_sigma*offset_sigma), \n",
- " min(np.power(2,14)-1,offset_median + badpixel_threshold_sigma*offset_sigma)),\n",
- " y_range=(0,max(ho)*1.1),\n",
- " y_log=True)\n",
- "\n",
- "fig2.suptitle('Offset Distribution',x=.5,y=.92,fontsize=16)\n",
- "\n",
- "stats_str = 'mean : ' + \"{:.2f}\".format(np.round(offset_mean,2)) \\\n",
- " + '\\nstd : ' + \"{:.2f}\".format(np.round(offset_sigma,2)) \\\n",
- " + '\\nmedian: ' + \"{:.2f}\".format(np.round(offset_median,2)) \\\n",
- " + '\\nmin: ' + \"{:.2f}\".format(np.min(constant_maps['Offset'].data.flatten())) \\\n",
- " + '\\nmax: ' + \"{:.2f}\".format(np.max(constant_maps['Offset'].data.flatten()))\n",
- "fig2.text(s=stats_str,x=.7,y=.7,fontsize=14,bbox=dict(facecolor='yellow', edgecolor='black', alpha=.1));\n",
- "\n",
+ "fig = xana.simplePlot(\n",
+ " do, \n",
+ " aspect = 1.5,\n",
+ " x_label = 'Offset [ADU]',\n",
+ " y_label = 'Counts',\n",
+ " x_range = (0, np.power(2,14)-1),\n",
+ " y_range = (0, max(ho)*1.1),\n",
+ " y_log = True\n",
+ ")\n",
+ "fig.suptitle('Offset Distribution', x=.5,y =.92, fontsize=16)\n",
+ "\n",
+ "stats_str = (\n",
+ " f'mean: {np.round(offset_mean,2)}\\n'\n",
+ " f'std : {np.round(offset_sigma,2)}\\n'\n",
+ " f'median: {np.round(offset_median,2)}\\n'\n",
+ " f'min: {np.round(offset_min,2)}\\n'\n",
+ " f'max: {np.round(offset_max,2)}'\n",
+ ")\n",
+ "fig.text(\n",
+ " s = stats_str,\n",
+ " x = .7,\n",
+ " y = .7,\n",
+ " fontsize = 14,\n",
+ " bbox = dict(facecolor='yellow', edgecolor='black', alpha=.1));"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## Noise ###"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
"#************** NOISE HEAT MAP **************#\n",
- "fig3 = xana.heatmapPlot(constant_maps['Noise'][:, :, 0],\n",
- " x_label='Columns', y_label='Rows',\n",
- " lut_label='Noise [ADU]',\n",
- " x_range=(0, sensorSize[1]),\n",
- " y_range=(0, sensorSize[0]),\n",
- " vmin=max(0,noise_median - badpixel_threshold_sigma*noise_sigma), \n",
- " vmax=noise_median + badpixel_threshold_sigma*noise_sigma)\n",
- "fig3.suptitle('Noise Map',x=.48,y=.9,fontsize=16)\n",
- "fig3.set_size_inches(h=15,w=15)\n",
+ "fig = xana.heatmapPlot(\n",
+ " constant_maps['Noise'][:, :, 0],\n",
+ " lut_label = '[ADU]',\n",
+ " x_label = 'Column', \n",
+ " y_label = 'Row',\n",
+ " x_range = (0, sensor_size[0]),\n",
+ " y_range = (0, sensor_size[1]),\n",
+ " vmin = max(0, noise_median - badpixel_threshold_sigma*noise_sigma), \n",
+ " vmax = noise_median + badpixel_threshold_sigma*noise_sigma\n",
+ ")\n",
+ "fig.suptitle('Noise Map', x=.5, y=.9, fontsize=16)\n",
+ "fig.set_size_inches(h=15, w=15)\n",
"\n",
"#************** NOISE HISTOGRAM **************#\n",
"binwidth = noise_sigma/100\n",
- "hn, cn = np.histogram(constant_maps['Noise'].data.flatten(),\n",
- " bins=np.arange((min(constant_maps['Noise'].data.flatten())),\n",
- " max(constant_maps['Noise'].data.flatten()) + binwidth,\n",
+ "hn, cn = np.histogram(constant_maps['Noise'].flatten(),\n",
+ " bins=np.arange((min(constant_maps['Noise'].flatten())),\n",
+ " max(constant_maps['Noise'].flatten()) + binwidth,\n",
" binwidth))\n",
"dn = {'x': cn[:-1],\n",
" 'y': hn,\n",
@@ -285,33 +328,40 @@
" 'drawstyle': 'bars',\n",
" 'color': 'cornflowerblue'}\n",
"\n",
- "fig4 = xana.simplePlot(dn,\n",
- " aspect=1.5,\n",
- " x_range=(max(0,noise_median - badpixel_threshold_sigma*noise_sigma), \n",
- " noise_median + badpixel_threshold_sigma*noise_sigma),\n",
- " y_range=(0,max(hn)*1.1),\n",
- " x_label='Noise [ADU]',\n",
- " y_label='Counts',\n",
- " y_log=True)\n",
- "\n",
- "fig4.suptitle('Noise Distribution',x=.5,y=.92,fontsize=16);\n",
- "\n",
- "stats_str = 'mean : ' + \"{:.2f}\".format(np.round(noise_mean,2)) \\\n",
- " + '\\nstd : ' + \"{:.2f}\".format(np.round(noise_sigma,2)) \\\n",
- " + '\\nmedian: ' + \"{:.2f}\".format(np.round(noise_median,2)) \\\n",
- " + '\\nmin : ' + \"{:.2f}\".format(np.min(constant_maps['Noise'].data.flatten())) \\\n",
- " + '\\nmax : ' + \"{:.2f}\".format(np.max(constant_maps['Noise'].data.flatten()))\n",
- "fig4.text(s=stats_str,x=.72,y=.7,fontsize=14, bbox=dict(facecolor='yellow', edgecolor='black', alpha=.1));"
+ "fig = xana.simplePlot(\n",
+ " dn,\n",
+ " aspect = 1.5,\n",
+ " x_label = 'Noise [ADU]',\n",
+ " y_label = 'Counts',\n",
+ " x_range = (max(0, noise_median - badpixel_threshold_sigma*noise_sigma), \n",
+ " noise_median + badpixel_threshold_sigma*noise_sigma),\n",
+ " y_range = (0, max(hn)*1.1),\n",
+ " y_log = True\n",
+ ")\n",
+ "fig.suptitle('Noise Distribution',x=.5,y=.92,fontsize=16);\n",
+ "\n",
+ "stats_str = (\n",
+ " f'mean: {np.round(noise_mean,2)}\\n'\n",
+ " f'std: {np.round(noise_sigma,2)}\\n'\n",
+ " f'median: {np.round(noise_median,2)}\\n'\n",
+ " f'min: {np.round(noise_min,2)}\\n'\n",
+ " f'max: {np.round(noise_max,2)}'\n",
+ ")\n",
+ "fig.text(\n",
+ " s = stats_str,\n",
+ " x = .7,\n",
+ " y = .7,\n",
+ " fontsize = 14,\n",
+ " bbox = dict(facecolor='yellow', edgecolor='black', alpha=.1));"
]
},
{
"cell_type": "markdown",
- "id": "02702ec6-0dbc-4cbf-9421-7cef2a6290c4",
"metadata": {},
"source": [
- "## Bad Pixel Map ###\n",
+ "## Bad Pixels Map ###\n",
"\n",
- "The bad pixel map is deduced by comparing offset and noise of each pixel ($v_i$) against its median value:\n",
+ "The bad pixel map is deduced by comparing offset and noise of each pixel ($v_i$) against the median value of the respective maps ($v_k$):\n",
"\n",
"$$ \n",
"v_i > \\mathrm{median}(v_{k}) + n \\sigma_{v_{k}}\n",
@@ -327,12 +377,18 @@
{
"cell_type": "code",
"execution_count": null,
- "id": "0edad7cd-e719-4274-a1f0-9d0ed0937ef2",
"metadata": {},
"outputs": [],
"source": [
"def print_bp_entry(bp):\n",
- " print(\"{:<30s} {:032b}\".format(bp.name, bp.value))\n",
+ " '''\n",
+ " Prints bad pixels bit encoding.\n",
+ " \n",
+ " Parameters\n",
+ " ----------\n",
+ " bp : enum 'BadPixels'\n",
+ " '''\n",
+ " print('{:<30s} {:032b}'.format(bp.name, bp.value))\n",
"\n",
"print_bp_entry(BadPixels.OFFSET_OUT_OF_THRESHOLD)\n",
"print_bp_entry(BadPixels.NOISE_OUT_OF_THRESHOLD)\n",
@@ -342,15 +398,29 @@
{
"cell_type": "code",
"execution_count": null,
- "id": "b71b82c2-206b-4862-a134-8ae3cc065780",
"metadata": {},
"outputs": [],
"source": [
- "def eval_bpidx(d):\n",
- "\n",
- " mdn = np.nanmedian(d, axis=(0, 1))\n",
- " std = np.nanstd(d, axis=(0, 1)) \n",
- " idx = (d > mdn + badpixel_threshold_sigma*std) | (d < mdn - badpixel_threshold_sigma*std)\n",
+ "def eval_bpidx(const_map, n_sigma):\n",
+ " '''\n",
+ " Evaluates bad pixels by comparing offset and noise of each\n",
+ " pixel against the median value of the respective maps.\n",
+ " \n",
+ " Returns boolean array\n",
+ " \n",
+ " Parameters\n",
+ " ----------\n",
+ " const_map : ndarray\n",
+ " Offset or noise constant map to input.\n",
+ " n_sigma : float\n",
+ " Standard deviation multiplicity interval outside\n",
+ " which bad pixels are defined.\n",
+ " '''\n",
+ " \n",
+ " mdn = np.nanmedian(const_map)\n",
+ " std = np.nanstd(const_map) \n",
+ " idx = ( (const_map > mdn + n_sigma*std)\n",
+ " | (const_map < mdn - n_sigma*std) )\n",
"\n",
" return idx"
]
@@ -358,23 +428,44 @@
{
"cell_type": "code",
"execution_count": null,
- "id": "f23ae7ca-cf5b-457c-9457-57e38f12a484",
- "metadata": {},
+ "metadata": {
+ "tags": []
+ },
"outputs": [],
"source": [
+ "# Add BadPixels to constant_maps\n",
"constant_maps['BadPixels'] = np.zeros(constant_maps['Offset'].shape, np.uint32)\n",
"\n",
- "constant_maps['BadPixels'][eval_bpidx(constant_maps['Offset'])] = BadPixels.OFFSET_OUT_OF_THRESHOLD.value\n",
- "constant_maps['BadPixels'][eval_bpidx(constant_maps['Noise'])] = BadPixels.NOISE_OUT_OF_THRESHOLD.value\n",
- "constant_maps['BadPixels'][~np.isfinite(constant_maps['Offset'])] = BadPixels.OFFSET_NOISE_EVAL_ERROR.value\n",
+ "# Noise related bad pixels\n",
+ "constant_maps['BadPixels'][eval_bpidx(constant_maps['Noise'], badpixel_threshold_sigma)] = BadPixels.NOISE_OUT_OF_THRESHOLD.value\n",
"constant_maps['BadPixels'][~np.isfinite(constant_maps['Noise'])] = BadPixels.OFFSET_NOISE_EVAL_ERROR.value\n",
"\n",
- "#************** BAD PIXLES HEAT MAP **************#\n",
- "fig5 = xana.heatmapPlot(constant_maps['BadPixels'][:, :, 0],\n",
- " x_label='Columns', y_label='Rows',\n",
- " lut_label='Noise (ADU)',\n",
- " x_range=(0, pixels_y),\n",
- " y_range=(0, pixels_x), vmax=2 * np.mean(constant_maps['Noise']))"
+ "# Offset related bad pixels\n",
+ "constant_maps['BadPixels'][eval_bpidx(constant_maps['Offset'], badpixel_threshold_sigma)] = BadPixels.OFFSET_OUT_OF_THRESHOLD.value\n",
+ "constant_maps['BadPixels'][~np.isfinite(constant_maps['Offset'])] = BadPixels.OFFSET_NOISE_EVAL_ERROR.value\n",
+ "\n",
+ "num_bad_pixels = np.sum(constant_maps['BadPixels']!=0)\n",
+ "\n",
+ "print('Number of Bad Pixels: ' + str(num_bad_pixels) + ' (' + str(np.round(100*num_bad_pixels/(sensor_size[0]*sensor_size[1]),2)) + '%)')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#************** BAD PIXELS HEAT MAP **************#\n",
+ "fig = xana.heatmapPlot(\n",
+ " np.log2(constant_maps['BadPixels'][:, :, 0]),\n",
+ " lut_label='Bad pixel bit assinged',\n",
+ " x_label = 'Column',\n",
+ " y_label = 'Row',\n",
+ " x_range = (0, sensor_size[0]),\n",
+ " y_range = (0, sensor_size[1])\n",
+ ")\n",
+ "fig.suptitle('Bad Pixels Map', x=.5, y=.9, fontsize=16)\n",
+ "fig.set_size_inches(h=15, w=15)"
]
},
{
@@ -384,52 +475,74 @@
"outputs": [],
"source": [
"# Save constants to DB\n",
- "dclass=\"ePix100\"\n",
"md = None\n",
"\n",
"for const_name in constant_maps.keys():\n",
- " det = getattr(Constants, dclass)\n",
- " const = getattr(det, const_name)()\n",
+ " const = getattr(Constants.ePix100, const_name)()\n",
" const.data = constant_maps[const_name].data\n",
"\n",
- " # set the operating condition\n",
- " condition = getattr(Conditions.Dark, dclass)(bias_voltage=bias_voltage,\n",
- " integration_time=integration_time,\n",
- " temperature=temperature_k,\n",
- " in_vacuum=in_vacuum)\n",
+ " # Set the operating condition\n",
+ " condition = Conditions.Dark.ePix100(\n",
+ " bias_voltage = bias_voltage,\n",
+ " integration_time = integration_time,\n",
+ " temperature = temperature_k,\n",
+ " in_vacuum = in_vacuum)\n",
+ " \n",
" for parm in condition.parameters:\n",
" if parm.name == \"Sensor Temperature\":\n",
" parm.lower_deviation = temp_limits\n",
" parm.upper_deviation = temp_limits\n",
"\n",
- " db_module = get_pdu_from_db(karabo_id, karabo_da, const,\n",
- " condition, cal_db_interface,\n",
- " snapshot_at=creation_time)[0]\n",
+ " # Get physical detector unit\n",
+ " db_module = get_pdu_from_db(\n",
+ " karabo_id = karabo_id,\n",
+ " karabo_da = karabo_da,\n",
+ " constant = const,\n",
+ " condition = condition,\n",
+ " cal_db_interface = cal_db_interface,\n",
+ " snapshot_at=creation_time)[0]\n",
"\n",
+ " # Inject or save calibration constants\n",
" if db_output:\n",
- " md = send_to_db(db_module, karabo_id, const, condition,\n",
- " file_loc=file_loc, report_path=report,\n",
- " cal_db_interface=cal_db_interface,\n",
- " creation_time=creation_time,\n",
- " timeout=cal_db_timeout)\n",
+ " md = send_to_db(\n",
+ " db_module = db_module,\n",
+ " karabo_id = karabo_id,\n",
+ " constant = const,\n",
+ " condition = condition,\n",
+ " file_loc = file_loc,\n",
+ " report_path = report,\n",
+ " cal_db_interface = cal_db_interface,\n",
+ " creation_time = creation_time,\n",
+ " timeout = cal_db_timeout\n",
+ " )\n",
" if local_output:\n",
- " md = save_const_to_h5(db_module, karabo_id, const, condition,\n",
- " const.data, file_loc, report,\n",
- " creation_time, out_folder)\n",
+ " md = save_const_to_h5(\n",
+ " db_module = db_module,\n",
+ " karabo_id = karabo_id,\n",
+ " constant = const,\n",
+ " condition = condition,\n",
+ " data = const.data,\n",
+ " file_loc = file_loc,\n",
+ " report = report,\n",
+ " creation_time = creation_time,\n",
+ " out_folder = out_folder\n",
+ " )\n",
" print(f\"Calibration constant {const_name} is stored locally at {out_folder} \\n\")\n",
"\n",
- "print(\"Constants parameter conditions are:\\n\")\n",
- "print(f\"• Bias voltage: {bias_voltage}\\n• Integration time: {integration_time}\\n\"\n",
- " f\"• Temperature: {temperature_k}\\n• In Vacuum: {in_vacuum}\\n\"\n",
- " f\"• Creation time: {md.calibration_constant_version.begin_at if md is not None else creation_time}\\n\")"
+ "print(\"Constants parameter conditions are:\\n\"\n",
+ " f\"• Bias voltage: {bias_voltage}\\n\"\n",
+ " f\"• Integration time: {integration_time}\\n\"\n",
+ " f\"• Temperature: {temperature_k}\\n\"\n",
+ " f\"• In Vacuum: {in_vacuum}\\n\"\n",
+ " f\"• Creation time: {md.calibration_constant_version.begin_at if md is not None else creation_time}\\n\")"
]
}
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3",
+ "display_name": "cal_venv",
"language": "python",
- "name": "python3"
+ "name": "cal_venv"
},
"language_info": {
"codemirror_mode": {
@@ -462,5 +575,5 @@
}
},
"nbformat": 4,
- "nbformat_minor": 1
+ "nbformat_minor": 4
}