diff --git a/docs/source/index.rst b/docs/source/index.rst index 47ec24066..b3254a06b 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -60,6 +60,12 @@ Straxen is the analysis framework for XENONnT, built on top of the generic `stra scripts bootstrax +.. toctree:: + :maxdepth: 2 + :caption: Auxilliary tools + + scada_interface + tutorials/ScadaInterfaceExample.ipynb .. toctree:: :maxdepth: 1 diff --git a/docs/source/reference/straxen.analyses.rst b/docs/source/reference/straxen.analyses.rst index 728b55083..48e6d36b2 100644 --- a/docs/source/reference/straxen.analyses.rst +++ b/docs/source/reference/straxen.analyses.rst @@ -4,6 +4,30 @@ straxen.analyses package Submodules ---------- +straxen.analyses.bokeh\_waveform\_plot module +--------------------------------------------- + +.. automodule:: straxen.analyses.bokeh_waveform_plot + :members: + :undoc-members: + :show-inheritance: + +straxen.analyses.daq\_waveforms module +-------------------------------------- + +.. automodule:: straxen.analyses.daq_waveforms + :members: + :undoc-members: + :show-inheritance: + +straxen.analyses.event\_display module +-------------------------------------- + +.. automodule:: straxen.analyses.event_display + :members: + :undoc-members: + :show-inheritance: + straxen.analyses.holoviews\_waveform\_display module ---------------------------------------------------- @@ -12,6 +36,22 @@ straxen.analyses.holoviews\_waveform\_display module :undoc-members: :show-inheritance: +straxen.analyses.posrec\_comparison module +------------------------------------------ + +.. automodule:: straxen.analyses.posrec_comparison + :members: + :undoc-members: + :show-inheritance: + +straxen.analyses.pulse\_plots module +------------------------------------ + +.. automodule:: straxen.analyses.pulse_plots + :members: + :undoc-members: + :show-inheritance: + straxen.analyses.quick\_checks module ------------------------------------- @@ -36,7 +76,6 @@ straxen.analyses.waveform\_plot module :undoc-members: :show-inheritance: - Module contents --------------- diff --git a/docs/source/reference/straxen.plugins.rst b/docs/source/reference/straxen.plugins.rst index eb58307ec..c17f734be 100644 --- a/docs/source/reference/straxen.plugins.rst +++ b/docs/source/reference/straxen.plugins.rst @@ -4,6 +4,14 @@ straxen.plugins package Submodules ---------- +straxen.plugins.acqmon\_processing module +----------------------------------------- + +.. automodule:: straxen.plugins.acqmon_processing + :members: + :undoc-members: + :show-inheritance: + straxen.plugins.daqreader module -------------------------------- @@ -12,6 +20,30 @@ straxen.plugins.daqreader module :undoc-members: :show-inheritance: +straxen.plugins.double\_scatter module +-------------------------------------- + +.. automodule:: straxen.plugins.double_scatter + :members: + :undoc-members: + :show-inheritance: + +straxen.plugins.event\_area\_per\_channel module +------------------------------------------------ + +.. automodule:: straxen.plugins.event_area_per_channel + :members: + :undoc-members: + :show-inheritance: + +straxen.plugins.event\_patternfit module +---------------------------------------- + +.. automodule:: straxen.plugins.event_patternfit + :members: + :undoc-members: + :show-inheritance: + straxen.plugins.event\_processing module ---------------------------------------- @@ -20,6 +52,30 @@ straxen.plugins.event\_processing module :undoc-members: :show-inheritance: +straxen.plugins.led\_calibration module +--------------------------------------- + +.. automodule:: straxen.plugins.led_calibration + :members: + :undoc-members: + :show-inheritance: + +straxen.plugins.nveto\_recorder module +-------------------------------------- + +.. automodule:: straxen.plugins.nveto_recorder + :members: + :undoc-members: + :show-inheritance: + +straxen.plugins.online\_monitor module +-------------------------------------- + +.. automodule:: straxen.plugins.online_monitor + :members: + :undoc-members: + :show-inheritance: + straxen.plugins.pax\_interface module ------------------------------------- @@ -44,6 +100,14 @@ straxen.plugins.peaklet\_processing module :undoc-members: :show-inheritance: +straxen.plugins.position\_reconstruction module +----------------------------------------------- + +.. automodule:: straxen.plugins.position_reconstruction + :members: + :undoc-members: + :show-inheritance: + straxen.plugins.pulse\_processing module ---------------------------------------- @@ -52,6 +116,38 @@ straxen.plugins.pulse\_processing module :undoc-members: :show-inheritance: +straxen.plugins.veto\_events module +----------------------------------- + +.. automodule:: straxen.plugins.veto_events + :members: + :undoc-members: + :show-inheritance: + +straxen.plugins.veto\_hitlets module +------------------------------------ + +.. automodule:: straxen.plugins.veto_hitlets + :members: + :undoc-members: + :show-inheritance: + +straxen.plugins.veto\_pulse\_processing module +---------------------------------------------- + +.. automodule:: straxen.plugins.veto_pulse_processing + :members: + :undoc-members: + :show-inheritance: + +straxen.plugins.veto\_veto\_regions module +------------------------------------------ + +.. automodule:: straxen.plugins.veto_veto_regions + :members: + :undoc-members: + :show-inheritance: + straxen.plugins.x1t\_cuts module -------------------------------- @@ -60,7 +156,6 @@ straxen.plugins.x1t\_cuts module :undoc-members: :show-inheritance: - Module contents --------------- diff --git a/docs/source/reference/straxen.rst b/docs/source/reference/straxen.rst index 4d10dd379..a3171de37 100644 --- a/docs/source/reference/straxen.rst +++ b/docs/source/reference/straxen.rst @@ -5,6 +5,7 @@ Subpackages ----------- .. toctree:: + :maxdepth: 4 straxen.analyses straxen.plugins @@ -12,6 +13,14 @@ Subpackages Submodules ---------- +straxen.bokeh\_utils module +--------------------------- + +.. automodule:: straxen.bokeh_utils + :members: + :undoc-members: + :show-inheritance: + straxen.common module --------------------- @@ -29,7 +38,7 @@ straxen.contexts module :show-inheritance: straxen.corrections\_services module -------------------------------------------- +------------------------------------ .. automodule:: straxen.corrections_services :members: @@ -37,23 +46,31 @@ straxen.corrections\_services module :show-inheritance: straxen.get\_corrections module ------------------------------------------ +------------------------------- .. automodule:: straxen.get_corrections :members: :undoc-members: :show-inheritance: -straxen.hitfinder\_thresholds -------------------------------------------- +straxen.hitfinder\_thresholds module +------------------------------------ .. automodule:: straxen.hitfinder_thresholds :members: :undoc-members: :show-inheritance: +straxen.holoviews\_utils module +------------------------------- + +.. automodule:: straxen.holoviews_utils + :members: + :undoc-members: + :show-inheritance: + straxen.itp\_map module -------------------------------------------- +----------------------- .. automodule:: straxen.itp_map :members: @@ -61,7 +78,7 @@ straxen.itp\_map module :show-inheritance: straxen.matplotlib\_utils module ---------------------------------------- +-------------------------------- .. automodule:: straxen.matplotlib_utils :members: @@ -69,15 +86,23 @@ straxen.matplotlib\_utils module :show-inheritance: straxen.mini\_analysis module ------------------------------------- +----------------------------- .. automodule:: straxen.mini_analysis :members: :undoc-members: :show-inheritance: +straxen.misc module +------------------- + +.. automodule:: straxen.misc + :members: + :undoc-members: + :show-inheritance: + straxen.mongo\_storage module ------------------------------------- +----------------------------- .. automodule:: straxen.mongo_storage :members: @@ -85,13 +110,21 @@ straxen.mongo\_storage module :show-inheritance: straxen.online\_monitor module ------------------------------------- +------------------------------ .. automodule:: straxen.online_monitor :members: :undoc-members: :show-inheritance: +straxen.rucio module +-------------------- + +.. automodule:: straxen.rucio + :members: + :undoc-members: + :show-inheritance: + straxen.rundb module -------------------- @@ -116,7 +149,6 @@ straxen.units module :undoc-members: :show-inheritance: - Module contents --------------- diff --git a/docs/source/scada_interface.rst b/docs/source/scada_interface.rst new file mode 100644 index 000000000..7a73cd0fd --- /dev/null +++ b/docs/source/scada_interface.rst @@ -0,0 +1,8 @@ +SCADA Interface +=============== +The SCADA Interface is a XENONnT specific tool which allows analysers and other tools to communicate +with our slow control database. The communication is done via different `webservice tools`_ provided +by the slow control team. Slow control data can be only accessed via midway. A little tutorial +notebook about the interface can be found in the subsequent notebook. + +.. _webservice tools: https://xe1t-wiki.lngs.infn.it/doku.php?id=xenon:xenon1t:slowcontrol:webserviceNew diff --git a/docs/source/tutorials/ScadaInterfaceExample.ipynb b/docs/source/tutorials/ScadaInterfaceExample.ipynb new file mode 120000 index 000000000..79c6f03fb --- /dev/null +++ b/docs/source/tutorials/ScadaInterfaceExample.ipynb @@ -0,0 +1 @@ +../../../notebooks/tutorials/ScadaInterfaceExample.ipynb \ No newline at end of file diff --git a/notebooks/tutorials/ScadaInterfaceExample.ipynb b/notebooks/tutorials/ScadaInterfaceExample.ipynb new file mode 100644 index 000000000..f55bafbd2 --- /dev/null +++ b/notebooks/tutorials/ScadaInterfaceExample.ipynb @@ -0,0 +1,638 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:58:43.069604Z", + "start_time": "2021-06-23T07:58:28.861529Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dwenz/mymodules/straxen/straxen/rucio.py:29: UserWarning: No installation of rucio-clients found. Can't use rucio remove backend\n", + " warnings.warn(\"No installation of rucio-clients found. Can't use rucio remove backend\")\n" + ] + } + ], + "source": [ + "import straxen\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tutorial SCADA-Python :\n", + "\n", + "In this notebook we show the basic functionalities of our SCADA interface. As a first step we have to initialize the interface. Please note that this is only possible for XENON members who are working on Midway. The straxen client will request a security token from our slowcontrol webservice. This token is only valid 3 hrs." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:58:43.842920Z", + "start_time": "2021-06-23T07:58:43.072337Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Received token, the token is valid for 3 hrs.\n", + " from 23.06. 07:58:43 UTC\n", + " till 23.06. 10:58:43 UTC\n", + "We will automatically refresh the token for you :). Have a nice day and a fruitful analysis!\n" + ] + } + ], + "source": [ + "sc = straxen.SCADAInterface()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After getting the token we can query some parameters. Lets try to get some data for a certain time range and set of different parameters. The parameters can be specified via a dictionary which takes as values the Historian database names of the required parameter and some short name as key. Let us query as an example some different parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:58:43.848209Z", + "start_time": "2021-06-23T07:58:43.845452Z" + } + }, + "outputs": [], + "source": [ + "parameters = {'para1': 'XE1T.CTPC.Board06.Chan011.VMon',\n", + " 'para2': 'XE1T.CRY_TE101_TCRYOBOTT_AI.PI',\n", + " 'para3': 'XE1T.CRY_PT101_PCHAMBER_AI.PI',\n", + " 'para4': 'XE1T.GEN_CE911_SLM1_HMON.PI',\n", + " 'para5': 'XE1T.CRY_FCV104FMON.PI',\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Feel free to give in your own analysis more meaningful parameter keys. Since it can be quite annoying to look up all those parameter names we also offer some functions which can return the corresponding names. For example for our PMTs the following function returns the high-voltage and current names:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:58:43.863028Z", + "start_time": "2021-06-23T07:58:43.850371Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'PMT10_HV': 'XE1T.CTPC.BOARD03.CHAN008.VMON',\n", + " 'PMT10_I': 'XE1T.CTPC.BOARD03.CHAN008.IMON',\n", + " 'PMT11_HV': 'XE1T.CTPC.BOARD04.CHAN002.VMON',\n", + " 'PMT11_I': 'XE1T.CTPC.BOARD04.CHAN002.IMON'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pmts = sc.find_pmt_names(range(10, 12), hv=True, current=True)\n", + "pmts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Beside the parameters we also have to specify the time range we would like to query. Since straxen handles time intervals in unix time nano-seconds it is natural to do the same here (Do not worry we can also query times in a human readable way which is shown below). " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:59:58.861353Z", + "start_time": "2021-06-23T07:58:43.865257Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4287bc8d7f9d4c86899e0f72f92ce8e0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Load parameters: 0%| | 0/5 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
para1para2para3para4para5
time UTC
2021-01-03 13:57:55+00:001253.800049-95.7198331.9350873.2157012.079859
2021-01-03 13:57:56+00:001253.800049-95.7144091.9347313.2157012.079859
2021-01-03 13:57:57+00:001253.800049-95.7218931.9351433.2157012.079859
2021-01-03 13:57:58+00:001253.800049-95.7106481.9351793.2157012.079859
2021-01-03 13:57:59+00:001253.800049-95.7146911.9342643.1791392.079859
\n", + "" + ], + "text/plain": [ + " para1 para2 para3 para4 \\\n", + "time UTC \n", + "2021-01-03 13:57:55+00:00 1253.800049 -95.719833 1.935087 3.215701 \n", + "2021-01-03 13:57:56+00:00 1253.800049 -95.714409 1.934731 3.215701 \n", + "2021-01-03 13:57:57+00:00 1253.800049 -95.721893 1.935143 3.215701 \n", + "2021-01-03 13:57:58+00:00 1253.800049 -95.710648 1.935179 3.215701 \n", + "2021-01-03 13:57:59+00:00 1253.800049 -95.714691 1.934264 3.179139 \n", + "\n", + " para5 \n", + "time UTC \n", + "2021-01-03 13:57:55+00:00 2.079859 \n", + "2021-01-03 13:57:56+00:00 2.079859 \n", + "2021-01-03 13:57:57+00:00 2.079859 \n", + "2021-01-03 13:57:58+00:00 2.079859 \n", + "2021-01-03 13:57:59+00:00 2.079859 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:59:59.206377Z", + "start_time": "2021-06-23T07:59:58.887105Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(df['para2'])\n", + "plt.xlabel('Time [UTC]')\n", + "plt.ylabel('Temperature at TE101 [°C]')\n", + "plt.xticks(rotation='45', horizontalalignment='right')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Querying data in a human readable way:\n", + "\n", + "Querying data with timestamps in nano-seconds unix times can be a bit tedious, especially, if you are not working with any straxen data. In order to allow a query in a human readable way we added some widgets:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:59:59.210153Z", + "start_time": "2021-06-23T07:59:59.207995Z" + } + }, + "outputs": [], + "source": [ + "tw = straxen.TimeWidgets()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After initialization you can render the widgets via..." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:59:59.277438Z", + "start_time": "2021-06-23T07:59:59.212570Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c9bed63910184e2fbffd776f5b840609", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(Dropdown(description='Time Zone:', options=(('CET', 0), ('UTC', 1)), value=0), H…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tw.create_widgets()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... and select any time range you would like. After specifying a time you can get the start and end time via:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:59:59.891006Z", + "start_time": "2021-06-23T07:59:59.278733Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1624424340000000000 1624427940000000000\n" + ] + } + ], + "source": [ + "start, end = tw.get_start_end()\n", + "print(start, end)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to this time widget we also offer analyst to query data via run_ids. This can be quite handy if you would like to correlate your data with other detector parameters. Further, you can also query data with a coarser binning e.g. every 300 seconds. Before we can use run_ids though we have to specify the context we are working with:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T07:59:59.945251Z", + "start_time": "2021-06-23T07:59:59.892856Z" + } + }, + "outputs": [], + "source": [ + "st = straxen.contexts.xenonnt_online()\n", + "sc.context = st" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T08:00:32.174880Z", + "start_time": "2021-06-23T08:00:29.378285Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d15dedc42d1b45ada18fd37d525f6300", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Load parameters: 0%| | 0/5 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
para1para2para3para4para5
time CET
2021-05-24 15:03:52+02:001211.0-96.1170811.887699-16.9632554.632631
2021-05-24 15:04:02+02:001211.0-96.1188131.888073-16.9583174.983373
2021-05-24 15:04:12+02:001211.0-96.1300961.887873-16.9582864.983373
2021-05-24 15:04:22+02:001211.0-96.1347811.888285-16.9583175.216488
2021-05-24 15:04:32+02:001211.0-96.1263431.887630-16.9583175.216488
\n", + "" + ], + "text/plain": [ + " para1 para2 para3 para4 para5\n", + "time CET \n", + "2021-05-24 15:03:52+02:00 1211.0 -96.117081 1.887699 -16.963255 4.632631\n", + "2021-05-24 15:04:02+02:00 1211.0 -96.118813 1.888073 -16.958317 4.983373\n", + "2021-05-24 15:04:12+02:00 1211.0 -96.130096 1.887873 -16.958286 4.983373\n", + "2021-05-24 15:04:22+02:00 1211.0 -96.134781 1.888285 -16.958317 5.216488\n", + "2021-05-24 15:04:32+02:00 1211.0 -96.126343 1.887630 -16.958317 5.216488" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfcet = straxen.convert_time_zone(df, 'CET')\n", + "dfcet.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2021-06-23T08:00:32.369995Z", + "start_time": "2021-06-23T08:00:32.193548Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dfcet['para2'].plot()\n", + "plt.xlabel('Time [CET]')\n", + "plt.ylabel('Temperature at TE101 [°C]')\n", + "plt.xticks(rotation='45', horizontalalignment='right')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/straxen/scada.py b/straxen/scada.py index 71d0729b3..c5c3b982c 100644 --- a/straxen/scada.py +++ b/straxen/scada.py @@ -214,7 +214,7 @@ def _get_and_check_start_end(self, run_id, start, end, time_selection_kwargs): mes = ('You are trying to query slow control data via run_ids' ' but you have not specified the context you are ' 'working with. Please set the context either via ' - '.st = YOURCONTEXT, or when initializing the ' + '.context = YOURCONTEXT, or when initializing the ' 'interface.') raise ValueError(mes) @@ -230,7 +230,7 @@ def _get_and_check_start_end(self, run_id, start, end, time_selection_kwargs): raise ValueError('You specified an endtime which is smaller ' 'than the start time.') - if len(str(start)) < 19 or len(str(end)) < 19: + if (np.log10(start) < 18) or (np.log10(end) < 18): raise ValueError('Expected the time to be in ns unix time (number with 19 digits or more).' ' Have you specified the time maybe in seconds or micro-seconds?')