{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Notebook setup for the pydoocs introduction:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n"
]
}
],
"source": [
"%pylab inline"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Setting the search path for modules to get the local path for the latest build (just for the demo here), and\n",
"assert that the latest pydoocs actually gets imported:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"import sys\n",
"import os\n",
"import time\n",
"\n",
"LOCAL_BUILD_PATH = \"/home/cbehrens/doocs/Darwin-x86_64/obj/library/python/pydoocs\"\n",
"sys.path.insert(0, LOCAL_BUILD_PATH) \n",
"\n",
"import pydoocs \n",
"\n",
"assert os.path.dirname(pydoocs.__file__) == LOCAL_BUILD_PATH"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Setting the test server base address being used throughout this demo:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"TEST_SERVER_BASE_ADDRESS = \"TEST.DOOCS/UNIT_TEST_SUPPORT/PY_DOOCS/\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Introduction to pydoocs\n",
"#### Table of contents (with internal links):\n",
"- [pydoocs module](#module)\n",
"- [read function](#read)\n",
" - [wildcard operation](#wildcard)\n",
"- [write function](#write)\n",
" - [write with output](#write-output)\n",
"- [names function](#names)\n",
"- [exceptions](#exceptions)\n",
"- [synchronized readout](#synchronized-readout)\n",
" - [via wildcard](#via-wildcard)\n",
" - [via macropulse](#via-macropulse)\n",
"- [supported data types](#data-types)\n",
"- [api breaking differences](#diff-previous)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## The pydoocs module:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The pydoocs' module docstring:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Python3 bindings to the standard DOOCS client API written in C/C++.'"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pydoocs.__doc__"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The current pydoocs version:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'2.0.0'"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pydoocs.__version__ "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The definitions (functions and exception classes) provided by the pydoocs module:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['DoocsException', 'PyDoocsException', 'names', 'read', 'write']"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[element for element in dir(pydoocs) if not element.startswith(\"__\")]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## The read function:\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The pydoocs' read function docstring:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Function to read data from a given DOOCS address.'"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pydoocs.read.__doc__"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"The read function takes at least 1 argument (the DOOCS address to read from) and at most 3 arguments, where the two optional keyword parameters are additional doocs parameters (keyword: parameters) and macropulse number (keyword: macropulse) for synchronization (see [via macropulse](#via-macropulse) below):"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Required argument 'address' (pos 1) not found\n"
]
}
],
"source": [
"try:\n",
" pydoocs.read()\n",
"except Exception as err:\n",
" print(err)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"function takes at most 3 arguments (4 given)\n"
]
}
],
"source": [
"try:\n",
" pydoocs.read(\"\", \"\", \"\", \"\")\n",
"except Exception as err:\n",
" print(err)"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"The output of the read function is a python dict with 5 key-value pairs, where the pair 'miscellaneous' is a dict itself and may be used to return additional information (see an example with a non-empty 'miscellaneous' further below):"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'data': 0,\n",
" 'macropulse': 17281873,\n",
" 'miscellaneous': {},\n",
" 'timestamp': 1528723309.669095,\n",
" 'type': 'BOOL'}"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"BOOL\")\n",
"output"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(output)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys(['data', 'type', 'timestamp', 'macropulse', 'miscellaneous'])"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output.keys()"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"The 'data' key-value pair contains data according to the requested type and can either be a scalar type (e.g. float, int, bool, ...) as shown above, or a list or a numpy array whenever appropriate as demonstrated in the cases below:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'data': array([[ 0. , 0. ],\n",
" [ 0.1 , 1. ],\n",
" [ 0.2 , 4. ],\n",
" [ 0.30000001, 9. ],\n",
" [ 0.40000001, 16. ],\n",
" [ 0.5 , 25. ],\n",
" [ 0.60000002, 36. ],\n",
" [ 0.69999999, 49. ],\n",
" [ 0.80000001, 64. ],\n",
" [ 0.90000004, 81. ]], dtype=float32),\n",
" 'macropulse': 0,\n",
" 'miscellaneous': {'comment': '', 'status': 0, 'timestamp': 1526992495},\n",
" 'timestamp': 1528724476.295571,\n",
" 'type': 'SPECTRUM'}"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"SPECTRUM\")\n",
"output"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(output[\"data\"])"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'data': [2, 1.2000000476837158, 2.299999952316284, 3.4000000953674316],\n",
" 'macropulse': 0,\n",
" 'miscellaneous': {},\n",
" 'timestamp': 1528713006.849212,\n",
" 'type': 'IFFF'}"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"IFFF_ARRAY\")\n",
"output"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"list"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(output[\"data\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"### wildcard (*) operation:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The wildcard '*' can be utilized to match all possible cases for a readout call, e.g. for reading a property for all locations:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"data type: A_USTR\n",
"first 5 of 54 data elements, each with [-, beam position, -, timestamp, location]: \n",
"[[0, 1.61899995803833, 0.0, 1528724476, '1GUN'],\n",
" [0, 2.0260000228881836, 0.0, 1528724476, '3GUN'],\n",
" [0, 0.0, 0.0, 1528724476, 'IDUMP'],\n",
" [0, 0.574999988079071, 0.0, 1528724476, '2UBC2'],\n",
" [0, 0.4066508710384369, 0.0, 1528724477, '9ACC1']]\n"
]
}
],
"source": [
"import pprint # for prettier printing\n",
"\n",
"output = pydoocs.read(\"FLASH.DIAG/BPM/*/X.FLASH1\") # with wildcard (*) for the DOOCS location\n",
"\n",
"print(\"data type: \", output[\"type\"])\n",
"print(\"first 5 of\", len(output[\"data\"]), \"data elements, each with [-, beam position, -, timestamp, location]: \")\n",
"pprint.pprint(output[\"data\"][:5])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## The write function:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The pydoocs' write function docstring:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Function to write data to a given DOOCS address.'"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pydoocs.write.__doc__"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"The write function takes at least 2 argument (the DOOCS address to write to and the data to write) and at most 3 arguments, where the optional keyword parameter is for additional doocs parameters (keyword: parameters):"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Required argument 'address' (pos 1) not found\n"
]
}
],
"source": [
"try:\n",
" pydoocs.write()\n",
"except Exception as err:\n",
" print(err)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Required argument 'data' (pos 2) not found\n"
]
}
],
"source": [
"try:\n",
" pydoocs.write(\"\")\n",
"except Exception as err:\n",
" print(err)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"function takes at most 3 arguments (4 given)\n"
]
}
],
"source": [
"try:\n",
" pydoocs.write(\"\", \"\", \"\", \"\")\n",
"except Exception as err:\n",
" print(err)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Writing to scalar-like data type: "
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"3\n"
]
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"INTEGER\")\n",
"print(output[\"data\"])\n",
"\n",
"pydoocs.write(TEST_SERVER_BASE_ADDRESS + \"INTEGER\", output[\"data\"] + 1) # increment the data by one\n",
"\n",
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"INTEGER\")\n",
"print(output[\"data\"])"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n"
]
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"BOOL\")\n",
"print(output[\"data\"])\n",
"\n",
"pydoocs.write(TEST_SERVER_BASE_ADDRESS + \"BOOL\", False if output['data'] else True) # negation\n",
"\n",
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"BOOL\")\n",
"print(output[\"data\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Writing to array-like data type: "
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 3, 4]\n",
"[4, 3, 2, 1]\n"
]
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"IIII_ARRAY\")\n",
"print(output[\"data\"])\n",
"\n",
"pydoocs.write(TEST_SERVER_BASE_ADDRESS +\"IIII_ARRAY\", output[\"data\"][::-1]) # reverse the data\n",
"\n",
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS +\"IIII_ARRAY\")\n",
"print(output[\"data\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Currently, writing to array-like data types requires a list for the input type, whereas numpy arrays might be returned as data type:"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 0. 0. ]\n",
" [ 0.1 1. ]\n",
" [ 0.2 4. ]\n",
" [ 0.30000001 9. ]\n",
" [ 0.40000001 16. ]\n",
" [ 0.5 25. ]\n",
" [ 0.60000002 36. ]\n",
" [ 0.69999999 49. ]\n",
" [ 0.80000001 64. ]\n",
" [ 0.90000004 81. ]]\n",
"[[ 0. -0. ]\n",
" [ 0.1 -1. ]\n",
" [ 0.2 -4. ]\n",
" [ 0.30000001 -9. ]\n",
" [ 0.40000001 -16. ]\n",
" [ 0.5 -25. ]\n",
" [ 0.60000002 -36. ]\n",
" [ 0.69999999 -49. ]\n",
" [ 0.80000001 -64. ]\n",
" [ 0.90000004 -81. ]]\n"
]
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"SPECTRUM\")\n",
"print(output[\"data\"])\n",
"\n",
"pydoocs.write(TEST_SERVER_BASE_ADDRESS + \"SPECTRUM\", list(-output[\"data\"][:,1])) # inverting sign of the data\n",
"\n",
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"SPECTRUM\")\n",
"print(output[\"data\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"### write call with output (remote procedure call like):"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"When implemented in the DOOCS server, remote procedure call like write calls with output can be realized:"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
},
{
"data": {
"text/plain": [
"{'data': 65,\n",
" 'macropulse': 0,\n",
" 'miscellaneous': {},\n",
" 'timestamp': 1528724478.0,\n",
" 'type': 'INT'}"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output = pydoocs.write(TEST_SERVER_BASE_ADDRESS + \"STRING\", \"A\") # standard address without RPC functionality\n",
"\n",
"output = pydoocs.write(TEST_SERVER_BASE_ADDRESS + \"D_INT_FROM_STRING_SET\", \"A\") # address which return the ASCII code\n",
"print(output is None) # for the given input character\n",
"output"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## The names function:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The pydoocs' names function docstring:"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Function to query names from a given DOOCS name domain.'"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pydoocs.names.__doc__"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"The names function uses the wildcard (*) on each of the four parts of a DOOCS given by Facility/Device/Location/Property. It takes exactly 1 argument:"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"function takes exactly 1 argument (0 given)\n"
]
}
],
"source": [
"try:\n",
" pydoocs.names()\n",
"except Exception as err:\n",
" print(err)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Find all available facilities and print the first 4 of them:"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"first 4 of 153 facilities found:\n",
"['TTF2.VAC', 'TTF2.RF', 'TTF2.DIAG', 'TTF2.DAQ']\n"
]
}
],
"source": [
"facilities = pydoocs.names(\"*\")\n",
"\n",
"print(\"first 4 of \", len(facilities), \" facilities found:\\n\", facilities[:4], sep='')"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"Find all available devices for the FLASH.DIAG facility and print the first 4 of them:"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"first 4 of 119 devices found in FLASH.DIAG:\n",
"['TIMER', 'BUNCHINFO', 'BEAMLINES', 'MCP.HV']\n"
]
}
],
"source": [
"devices = pydoocs.names(\"FLASH.DIAG/*\")\n",
"\n",
"print(\"first 4 of \", len(devices), \" devices found in FLASH.DIAG:\\n\", devices[:4], sep='')"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"Find all available location for the FLASH.DIAG/BPM device and print the first 4 of them:"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"first 4 of 126 locations found in FLASH.DIAG/BPM:\n",
"['FLASHCPUDIAG2._SVR', '1GUN', '3GUN', 'IDUMP']\n"
]
}
],
"source": [
"locations = pydoocs.names(\"FLASH.DIAG/BPM/*\")\n",
"\n",
"print(\"first 4 of \", len(locations), \" locations found in FLASH.DIAG/BPM:\\n\", locations[:4], sep='')"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"Find all available properties for the FLASH.DIAG/BPM/1GUN location and print the first 4 of them:"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"first 4 of 328 properties found in FLASH.DIAG/BPM/1GUN:\n",
"['NAME = location', 'STS gen.Status word', 'STS.ERROR pending error status', 'STS.NEWERROR new error detected']\n"
]
}
],
"source": [
"properties = pydoocs.names(\"FLASH.DIAG/BPM/1GUN/*\")\n",
"\n",
"print(\"first 4 of \", len(properties), \" properties found in FLASH.DIAG/BPM/1GUN:\\n\", properties[:4], sep='')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## Exceptions:\n",
"Pydoocs comes with two custom exceptions, DoocsException and PyDoocsException. The former is related to DOOCS specific exceptions and errors, and the latter for pydoocs specific ones. Both are definitions (classes) of the pydoocs module, and they can be raised by any pydoocs function."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The pydoocs' DoocsException exception docstring:"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\"Custom DOOCS exception with dict_keys(['code', 'message']) in its first argument.\""
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pydoocs.DoocsException.__doc__"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The pydoocs' PyDoocsException exception docstring:"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Custom pydoocs exception with specific message.'"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pydoocs.PyDoocsException.__doc__"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"Here we read an incomplete DOOCS address (the property part is missing), and the read function raises a DoocsException:"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'code': 101, 'message': 'illegal service'}\n",
"({'code': 101, 'message': 'illegal service'},)\n",
"101\n",
"illegal service\n"
]
}
],
"source": [
"try:\n",
" pydoocs.read(TEST_SERVER_BASE_ADDRESS)\n",
"except pydoocs.DoocsException as err:\n",
" print(err)\n",
" print(err.args) # the err.args attribute is a list with a dict in its first element\n",
" print(err.args[0]['code']) # the DOOCS specific error code\n",
" print(err.args[0]['message']) # the DOOCS specific error message"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we write an argument with the wrong format (float instead of bool or int), and the write function raises a PyDoocsException:"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"wrong input data format\n",
"('wrong input data format',)\n",
"wrong input data format\n"
]
}
],
"source": [
"try:\n",
" pydoocs.write(TEST_SERVER_BASE_ADDRESS + \"BOOL\", 1.5)\n",
"except pydoocs.PyDoocsException as err:\n",
" print(err)\n",
" print(err.args) # the err.args attribute is a list with a str in its first element\n",
" print(err.args[0]) # the pydoocs specific exception message"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Both custom exceptions in the pydoocs module are subclasses of Exception:"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"issubclass(pydoocs.DoocsException, Exception) and issubclass(pydoocs.PyDoocsException, Exception)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The exception 'Exception' can thus be catched in both cases:"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'code': 101, 'message': 'illegal service'}\n",
"\n"
]
}
],
"source": [
"try:\n",
" pydoocs.read(TEST_SERVER_BASE_ADDRESS)\n",
"except Exception as err:\n",
" print(err)\n",
" print(type(err)) # the actual (dynamic) exception type"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"wrong input data format\n",
"\n"
]
}
],
"source": [
"try:\n",
" pydoocs.write(TEST_SERVER_BASE_ADDRESS + \"BOOL\", 1.5)\n",
"except Exception as err:\n",
" print(err)\n",
" print(type(err)) # the actual (dynamic) exception type"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## Synchronized readout"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pydoocs has two way to get synchronized data, one of them is very limited (via wildcard) and the other one (via macropulse) is only party supported on the DOOCS server side and buggy (see also information below). The latter will certainly improve over time and with usage. "
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"\n",
"### via wildcard:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Synchronized readout via wildcard (see also [wildcard operation](#wildcard) above) can be achieved in the following way:"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'10DBC2': {'charge': 0.34880000352859497, 'macropulse': 1528724478},\n",
" '11SMATCH': {'charge': 0.3465000092983246, 'macropulse': 1528724478},\n",
" '12EXP': {'charge': 0.34404999017715454, 'macropulse': 1528724478},\n",
" '18ACC7': {'charge': 0.34599998593330383, 'macropulse': 1528724478},\n",
" '1UBC3': {'charge': 0.34825000166893005, 'macropulse': 1528724478},\n",
" '2SDUMP': {'charge': nan, 'macropulse': 1528711230},\n",
" '2UBC2': {'charge': 0.34325000643730164, 'macropulse': 1528724478},\n",
" '3GUN': {'charge': 0.34850001335144043, 'macropulse': 1528724478},\n",
" '4TCOL': {'charge': 0.34860000014305115, 'macropulse': 1528724478},\n",
" '5DBC3': {'charge': 0.3497999906539917, 'macropulse': 1528724478},\n",
" '7ORS': {'charge': 0.3458999991416931, 'macropulse': 1528724478},\n",
" '9DUMP': {'charge': 0.34244999289512634, 'macropulse': 1528724478}}"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output = pydoocs.read(\"FLASH.DIAG/TOROID.ML/*/CHARGE.FLASH1\")\n",
"toroids = {element[4]: {\"charge\": element[1], \n",
" \"macropulse\": element[3]} for element in output['data']} # create a dict for improved output\n",
"toroids"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Each device (when implemented and running properly) has the same macropulse number. A demonstration would be to show an existing correlation, which only shows up when the readout is synchronized:"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3X+Q3HWd5/HnK8OAQ1QGLoGDCQjh52JhEpwF7kAPUQk/\nUiTAIsTlsIotWTyxgNVQyRbn4eJVItESbotalmXZ8oqSH7smOTSUUeGUkjswk0sgRoiEVCAZXBLB\n8Q4cYTJ53x/97cl3+ue3e7oz3T2vRxXV3Z/vj/58SNLv7+e3IgIzM7O0aZOdATMzaz0ODmZmVsTB\nwczMijg4mJlZEQcHMzMr4uBgZmZFMgUHSRdJ2ippm6SlJY4vlPSCpE2SBiSdlzq2Q9Lm/LFU+lWS\ntkjaJ6m/McUxM7NGULV5DpK6gF8DnwZ2AeuBxRHxq9Q57wfeiYiQ9BHgsYg4LTm2A+iPiN8W3PdP\ngH3A3wNfiYgBzMysJRyU4ZyzgG0RsR1A0iPAQmAsOETE26nzpwNVZ9ZFxIvJ/WrJr5mZHQBZgkMf\nsDP1eRdwduFJki4HlgNHApemDgXwE0mjwN9HxP31ZnbGjBlx/PHH13u5mdmUtGHDht9GxMxarskS\nHDKJiNXAakkfB+4EPpUcOi8iBiUdCfxY0ksR8XTW+0q6AbgB4LjjjmNgwK1PZma1kPRqrddk6ZAe\nBI5NfZ6VpJWU/PDPljQj+TyYvO4GVpNrpsosIu6PiP6I6J85s6bAZ2ZmdcoSHNYDJ0s6QdLBwDXA\n4+kTJJ2kpPNA0pnAIcCbkqZL+kCSPh24EPhlIwtgZmaNV7VZKSL2SroJWAd0AQ9GxBZJNybH7wOu\nBK6TNAIMA1cnI5eOItfUlP+u70bED2Gsj+JvgZnAWkmbImJ+44toZma1qjqUtZX09/eH+xzMzGoj\naUNE1DSfzDOkzcysSMNGK5mZWeOt2TjIynVbeX1omGN6e1gy/1QWzetr+vc6OJiZtag1GwdZtmoz\nwyOjAAwODbNs1WaApgcINyuZmbWoleu2jgWGvOGRUVau29r073ZwMDNrUa8PDdeU3kgODmZmLeqY\n3p6a0hvJwcHMrEUtmX8qPd1d49J6urtYMv/Upn+3O6TNzFpUvtPZo5XMzGycRfP6DkgwKORmJTMz\nK+LgYGZmRRwczMysiIODmZkVcXAwM7MiDg5mZlbEwcHMzIo4OJiZWREHBzMzK+LgYGZmRRwczMys\niIODmZkV8cJ7ZmZNMFl7PzdKppqDpIskbZW0TdLSEscXSnpB0iZJA5LOSx3bIWlz/lgq/QhJP5b0\ncvJ6eGOKZGY2ufJ7Pw8ODRPs3/t5zcbByc5aZlWDg6Qu4F7gYuB0YLGk0wtOexKYExFzgeuBBwqO\nfyIi5kZEfyptKfBkRJycXF8UdMzM2tFk7v3cKFlqDmcB2yJie0S8BzwCLEyfEBFvR0QkH6cDQXUL\nge8k778DLMqWZTOz1jaZez83Spbg0AfsTH3elaSNI+lySS8Ba8nVHvIC+ImkDZJuSKUfFRG/Sd7/\nK3BUTTk3M2tRk7n3c6M0bLRSRKyOiNPI1QDuTB06L2luuhj4oqSPl7g2KFPbkHRD0o8xsGfPnkZl\n18ysaSZz7+dGyRIcBoFjU59nJWklRcTTwGxJM5LPg8nrbmA1uWYqgDckHQ2QvO4uc7/7I6I/Ivpn\nzpyZIbtmZpNr0bw+ll9xBn29PQjo6+1h+RVntNVopSxDWdcDJ0s6gVxQuAb4bPoESScBr0RESDoT\nOAR4U9J0YFpE/L/k/YXA3ySXPQ58DliRvP6PRhTIzKwVTNbez41SNThExF5JNwHrgC7gwYjYIunG\n5Ph9wJXAdZJGgGHg6iRQHAWslpT/ru9GxA+TW68AHpP0F8CrwGcaXDYzM6uT9g8yan39/f0xMDBQ\n/UQzMxsjaUPBVIKqvHyGmZkVcXAwM7MiDg5mZlbEwcHMzIo4OJiZWREHBzMzK+LgYGZmRRwczMys\niIODmZkVcXAwM7MiDg5mZlbEwcHMzIo4OJiZWREHBzMzK+LgYGZmRRwczMysiIODmZkVcXAwM7Mi\nDg5mZlbkoMnOgJlZq1izcZCV67by+tAwx/T2sGT+qSya1zfZ2ZoUDg5mZuQCw7JVmxkeGQVgcGiY\nZas2A0zJAOHgYGaTotWe0leu2zoWGPKGR0ZZuW6rg0M5ki4C7gG6gAciYkXB8YXAncA+YC9wS0T8\nPHW8CxgABiNiQZI2B7gPeD+wA/jziPi/Ey2QmbW+iT6l1xtYKl33+tBwyWvKpXe6qh3SyQ/7vcDF\nwOnAYkmnF5z2JDAnIuYC1wMPFBy/GXixIO0BYGlEnAGsBpbUnn0za0eVntKryQeWwaFhgv2BZc3G\nwQldd0xvT8nryqV3uiyjlc4CtkXE9oh4D3gEWJg+ISLejohIPk4H8u+RNAu4lOKAcQrwdPL+x8CV\ntWffzNrJmo2DnLviKQYn8JReb2Cpdt2S+afS09017nhPdxdL5p9aNU+dKEtw6AN2pj7vStLGkXS5\npJeAteRqD3l3A7eRa3JK28L+IHMVcGypL5d0g6QBSQN79uzJkF0za0XpJ/dysjyl19v8U+26RfP6\nWH7FGfT19iCgr7eH5VecMSX7G6CBHdIRsRpYLenj5PofPiVpAbA7IjZIOr/gkuuB/ybpPwOPA++V\nue/9wP0A/f39UeocM2t9pZ7c07I+pR/T21MywFQLLFmuWzSvb8oGg0JZag6DjH+qn5WklRQRTwOz\nJc0AzgUuk7SDXHPUBZIeSs57KSIujIiPAg8Dr9RXBDNrB5We7Gt5Sq+3+cfNRrXJUnNYD5ws6QRy\nQeEa4LPpEySdBLwSESHpTOAQ4M2IWAYsS845H/hKRFybfD4yInZLmgbcTm7kkpm1qWojiMo9udcq\nf89aRyvVe91UVTU4RMReSTcB68gNZX0wIrZIujE5fh+5zuTrJI0Aw8DVqQ7qchZL+mLyfhXwT/UW\nwswmV5ahqUvmnzrunLRah7LW2/zjZqPsVP03vHX09/fHwMDAZGfDzAqUG4HU19vDM0svGPucr12U\nq0EUnm+NIWlDRPTXco0X3jOzCcs6gmjRvD6eWXoBqvE+duA5OJjZhNU6gcwTzlqfg4OZZZKfwHbC\n0rWcu+KpcTOSax0J5JFDrc8L75lZVdU6nGsdCeSRQ63PHdJmVlXWDmdrTe6QNrOm8IqlU4+Dg5lV\n5Q7kqcfBwcyqcgfy1OMOabMOVuumOOXOdwfy1OPgYNahat1tLcuIJAeDqcPBwaxDVdsTubCW8M67\nezPvodxq+z9b4zk4mHWoSiOMStUSst5novs/W3twh7RZh6o0wqjaxjuV7jOR/Z+tfTg4mHWoSiOM\nss5PmJbcJ81zHqYGBwezDpNfA+nWRzdxyEHTOPzQ7qI9kbPOT9gHDLz61rg0z3mYGhwczDpIvj9g\ncGiYAIaGR/jjyD6+ffVcnll6wbiNdwprFeU8/NzOcZ8952FqcHAw6yDl+gNueXTTuJVUF83rY/kV\nZ9DX2zNWqyhntGD9tVLXZt3/2dqHRyuZdZBK7f6DQ8Ms+ZfngdLzFk5c9kRRIADoUvHWPJ7z0Plc\nczDrINXa/UdGg699f0vJY4vPPramdOtsrjmYtbhKE85uX7OZh5/byWgEXRLnzD6ct955r+Iw1d/9\nYaRk+tcXnQEw7n6Lzz52LN2mFgcHsxZQLgBUmnA28OpbPPTsa2P3GI3gmVfe4twTj2DHm8MVJ7aV\n8/VFZzgYGJCxWUnSRZK2StomaWmJ4wslvSBpk6QBSecVHO+StFHSD1JpcyU9m7rmrIkXx6z9FI4w\nygeAfMAoN+GscBRR3rPbf8czSy+gt6e75PFy6WZpVYODpC7gXuBi4HRgsaTTC057EpgTEXOB64EH\nCo7fDLxYkHYX8LXkmq8mn82mnEoBoFwH8+DQcMnOY9g/uuiOyz5M97Txncnd08Qdl324Abm2Tpel\n5nAWsC0itkfEe8AjwML0CRHxduzfb3Q6MPa3VtIs4FKKA0YAH0zeHwa8Xnv2zdpfpRnH9Uwsy48u\nWjSvj5VXzRk35HTlVXM8ysgyydLn0Aek66+7gLMLT5J0ObAcOJJcMMi7G7gN+EDBJbcA6yR9k1yQ\n+vfZs23WOY7p7SnZP5Dve0j3OWSRHl3kIadWr4YNZY2I1RFxGrAIuBNA0gJgd0RsKHHJF4BbI+JY\n4FbgH0vdV9INSZ/EwJ49exqVXbOWUWnGcX7CWSX5mkKXxLXnHOcOZWsIRZl2y7ETpH8H3BER85PP\nywAiYnmFa7aTa476MvAfgb3A+8g1I62KiGsl/R7ojYiQJOD3EfHBcvcE6O/vj4GBgcyFM2sX1fZH\nOHfFUyVrF329PTyz9IIDmVVrQ5I2RER/TddkCA4HAb8GPgkMAuuBz0bEltQ5JwGvJD/0ZwLfB2al\n+iGQdD7wlYhYkHx+EfhCRPxU0ieBuyLio5Xy4uBg7aZRm+IUDmlN83wEq6ae4FC1zyEi9kq6CVgH\ndAEPRsQWSTcmx+8DrgSukzQCDANXR7WoA58H7kmCzx+BG2rJuFmra+SmOOk9nAtrEKMRY/MdHCCs\nUarWHFqJaw7WTprVFFRpDaRXll9S932tczWl5mBm9alnU5wszVDV5jeYNYKDg1kdsvyIlxuiKsHc\nr/2I3w+PZF4qI33vLqlsIMgvyd2Ifg6b2rwqq1mNKi13kVZuQ519kduEp5alMtIqrZK65J+fZ8m/\nPF81b2bVuM/BrEa19CWs2TjIlx97vmqTT19vD68nP+iVjudrAoWL7lXjIa9TWz19Dq45mNWolr6E\nRfP62JfhAazaUhmFNYH+Dx1B8RY8le9vVgsHB7MalfsRrzW98Jys+zrnm5pqWXepnjWabGpzcDCr\n0ZL5pxb9w5mWpENuA54Tlz3B8UvX5l7/TU/FH/3CpTJKbctZ6PWh4ZLBpHua6O4af33+/ma1cHAw\nq9HAq2+xryBtH3Dv/3yZE5au5aFnXxvrY8hvwHPmcYeNrY56+KHd9PZ0j62UuvyKM8ZGE2Vthjqs\np3ssmBSuurryz8avxJq+v1lWHspqVqNym+y8vPudstc8u/13mSeolRsCm5avXJRbddXBwCbKwcEs\nZSKT0Cqpdk36e3sP7aZ7mhjZV/6aoTL7QJs1ioODWSLrJDRB2SGn5VTqRyj83t/9YYTuLtHb083Q\ncOkg4A5mazb3OZglsk5CO/ig2v/ZVJq4Vup7R0aD6YccxN1Xzy2714NZM7nmYJbIOn/h3b2F3dGV\nFW7AU9h0Va5/4fWh4XGrsZZq6mrUkuBmhRwczBKVtuvMKr/uUbk9Fko1XZVrpsp/b7lO50YuCW5W\nyMHBLFFqv+ZSTTjl+gJ6e7rZ9F8urPgdpZqQguJ+jCxNR5WawRwcbKIcHGzKun3NZh5+biejEQg4\n9OAuhkdGx57++5JmGsitp5Rvulkw52i++9xrpAcTTRMsmHP0uPNKNfGUa7oKitdPqvYDX8+S4GZZ\nOTjYlHT7ms3jFq4L4J33ck/hoxHjntwLm24eXb+zuB0o4NH1OxkZjbHzSjXxlGu6qmdhvEY0g5mV\n49FKNiWVm8iWl2+eKTeSqNQM6XxgKLxHWqklL+odfdTIe5kVcs3BpqQsE9mqzVLOorCJp9roo1o0\n8l5mhRwcbEqqtJtaXj2T3QqVauIpN/qoHo28l1mam5VsSqo0KQ0qB4buLtE9bfyMZ6+Gap3GNQfr\naOUmifV/6Age/sVORkusX9RXZeG7lX82J/dacN9SaX6qt3aVKThIugi4B+gCHoiIFQXHFwJ3kuuX\n2wvcEhE/Tx3vAgaAwYhYkKQ9CuQfq3qBoYiYO7HimO1XaZLYynVbywaGZ5ZeUHEr0PTy2oUcDKxT\nVG1WSn7Y7wUuBk4HFks6veC0J4E5yY/79cADBcdvBl5MJ0TE1RExN7nme8Cq+opgVlqlSWLV5gh4\nJJBNdVlqDmcB2yJiO4CkR4CFwK/yJ0TE26nzp5NqrpU0C7gU+K/AXxXeXJKAzwDe/dyqSk9cK7dE\nRV6lAFBtjkDWkUBe28g6VZbg0AekB4XvAs4uPEnS5cBy4EhywSDvbuA24ANl7v8x4I2IeDlLhm3q\nKpy4Nhox9rlUgDj04K6xiW2F6VmWyqg2EshrG1kna9hopYhYHRGnAYvI9T8gaQGwOyI2VLh0MfBw\nuYOSbpA0IGlgz549jcqutaFyE9ceevY1Tli6lnNXPMWajYNj6X8oERjy6aW22Kx1O82sS3ybtaMs\nNYdBID3ub1aSVlJEPC1ptqQZwLnAZZIuAd4HfFDSQxFxLYCkg4ArgI9WuN/9wP0A/f39Ex12bm2s\n0ryEoPjJvdzZ+fSJzhHw2kbWybLUHNYDJ0s6QdLBwDXA4+kTJJ2U9B0g6UzgEODNiFgWEbMi4vjk\nuqfygSHxKeCliNjVgLJYh6u0m1pe+sm93PlZ7pNFuTWMvLaRdYKqNYeI2CvpJmAduaGsD0bEFkk3\nJsfvA64ErpM0AgwDV0dk2mj3Gio0KdnUVtjZe87sw3nmlbeqXjc4NMyJy55g9sxDeXn3O0XHq02A\nyyrrEt9m7UjZfsNbQ39/fwwMDEx2NqyJ8gGh1Eii7mni+Bmlf/DLOfnI6Wzf84dMo5smkl+PVrJW\nJmlDRPTXdI2Dg7WKwtE/jdAl8crySxp2P7N2VE9w8PIZ1jJKjf7JotIieqMRZTfg8VO/WXkODtYy\n6h3lsy9pMioXIPJNVOnRTFC8iY/nKJjt51VZrWXUO8qn99DuzJ3MlTbx8RwFs/0cHKxllFrPKIuI\n3Azpa885LtMw1deHhj1HwawKBwdrGYWzlnt7ujn80O6xGczlDA2PsGbjIF9fdAbf+sycqgHmfd3T\nPEfBrAr3OVhLqTRred7f/Ijf/WGk5LH0UtzVOrXf3bvPcxTMqnBwsElT62ihSqOuqy3FnbYvvP+y\nWTUODjYp6lnR9PfDpWsNea8PDXNYTzdDVc7L90t4/2Wz8tznYJOintFCh/V0V7znMb09ZFk2qVHL\nZ5h1MgcHmxS1jBa6fc1mTlz2RMUaQb6/YKhMnwTkagzXnnNcQ5fPMOtUDg42KbKOFspv8FNpuW5g\nbC+Gcvft6+3hleWXODCYZeTgYJOi1JwGket7SG/aU26Dn7S+3p6xvgPv/WzWGO6QtkmRHi00ODSM\n2L8JT75zeuDVt6rWGEpt7Zm/r0chmdXPq7LapDt3xVMll+hOB4xS+vzDb5aJV2W1tlSuc7pSYOjp\nnsYzSy9oTobMzMHBGqfeJbCP6e0pWXOo5I8j++rNppll4A5pa4j8pLbBoWGC/f0G+Y7lSsp1Tlfi\nNZDMmsvBwRpiIktgFy6419fbw5+fc1zZBfQ8+sis+dysZA0x0SWwSy1l0f+hI8ZGM+U383EntNmB\n4eBgDVGu32AizT9e+8hs8rhZyapas3GQc1c8xQlL146boJbmyWdmnSVTcJB0kaStkrZJWlri+EJJ\nL0jaJGlA0nkFx7skbZT0g4L0L0l6SdIWSXdNrCjWDFk7mkv1G+SXtDCz9lO1WUlSF3Av8GlgF7Be\n0uMR8avUaU8Cj0dESPoI8BhwWur4zcCLwAdT9/0EsBCYExHvSjpywqWxhqvU0Vz4w+9mILPOkaXm\ncBawLSK2R8R7wCPkftTHRMTbsX+q9XRS85ckzQIuBR4ouO8XgBUR8W5yj931FcGayXstm01NWYJD\nH5Be/WxXkjaOpMslvQSsBa5PHbobuA0onLV0CvAxSc9J+pmkPy315ZJuSJqqBvbs2ZMhu9ZIvYeW\n3kOhXHqhLP0VZtZ6GtYhHRGrI+I0YBFwJ4CkBcDuiNhQ4pKDgCOAc4AlwGNS8VYtEXF/RPRHRP/M\nmTMblV3LqNzSW1mW5JrIxDgzm1xZgsMgkN46a1aSVlJEPA3MljQDOBe4TNIOcs1RF0h6KDl1F7Aq\ncn5BrmYxo/YiWDOV25qz2padMLGJcWY2ubIEh/XAyZJOkHQwcA3wePoESSfln/olnQkcArwZEcsi\nYlZEHJ9c91REXJtctgb4RHLNKcDBwG8bUCbLKEuTT9ZNeUpxf4VZ+6oaHCJiL3ATsI7ciKPHImKL\npBsl3ZicdiXwS0mbyI1sujqqrwX+ILkaxi/J1So+l+Eaa5CsTT4Tmb8wkcBiZpPL+zlMUeX2UOjr\n7SlaCrve1VbzASjdtNTT3eX5D2YHmPdzsMzKNe3kt+ksDAT1/JgvmtfHwKtv8fBzOxmNoEviyo96\nLoRZO/DyGVNUuaad/D7OjRhdtGbjIN/bMDi21edoBN/bMOjRSmZtwMFhiiq3h0JhI2Ph6KLb12zm\nxGVPcPzStZy47AluX7O57Hd4tJJZ+3JwmKJKrYVUrvcp3wR1+5rNPPTsa+NqAg89+1rZAOHRSmbt\ny30OU1hhX0K5Tup8E9TDz+0sOpZP//qiM0pe1+hlvM3swHDNoYUd6KUnqg1bHS0zsq1cupfxNmtf\nrjm0qMJhoPnOYaBpo33y9y03bDW/G1uhruJVTzLdz8xal4NDi6plqexGqjRsdfHZx/LQs6+VTK/n\nfmbWuhwcWlQrdubm+xXS8xYWn31syf4GM2tvDg4tqlU7c7++6AwHA7MpwB3SLcqduWY2mVxzaFET\n7cytdz0kMzNwcGhp9XbmTsZIJzPrLA4Ok6DZT/WTNdLJzDqHg8MBVs9Tfa3BpBVHOplZe3GH9AFW\n62J09ezD7E12zGyiHBwOsFqf6utZ2dQjncxsohwcDrBan+rraSIqteKqd18zs1q4z+EAWzL/1JJb\nZ5Z7qq93MpyXrTCziXDN4QCr9aneTURmNhlcc5gEtTzVe2VTM5sMmYKDpIuAe4Au4IGIWFFwfCFw\nJ7AP2AvcEhE/Tx3vAgaAwYhYkKTdAXwe2JOc9tcR8cSEStOh3ERkZgda1eCQ/LDfC3wa2AWsl/R4\nRPwqddqTwOMREZI+AjwGnJY6fjPwIvDBgtt/OyK+OZECtDMvcWFmrSpLn8NZwLaI2B4R7wGPAAvT\nJ0TE2xFju8BMJ7VPvaRZwKXAA43JcmeoZ/6CmdmBkiU49AHpzYN3JWnjSLpc0kvAWuD61KG7gdvI\nNTkV+pKkFyQ9KOnw7Nluf/XMXzAzO1AaNlopIlZHxGnAInL9D0haAOyOiA0lLvk7YDYwF/gN8K1S\n95V0g6QBSQN79uwpdUpb8hIXZtbKsgSHQSC9D+SsJK2kiHgamC1pBnAucJmkHeSaoy6Q9FBy3hsR\nMRoR+4B/INd8Vep+90dEf0T0z5w5M0uZ2oKXuDCzVpYlOKwHTpZ0gqSDgWuAx9MnSDpJyu0yL+lM\n4BDgzYhYFhGzIuL45LqnIuLa5LyjU7e4HPjlhEvTRjx/wcxaWdXRShGxV9JNwDpyQ1kfjIgtkm5M\njt8HXAlcJ2kEGAauTnVQl3OXpLnkOq93AH9ZfzHaj+cvmFkrU/Xf8NbR398fAwMDk50NM7O2ImlD\nRPTXco2XzzAzsyIODmZmVsTBwczMijg4mJlZEQcHMzMr4uBgZmZFHBzMzKyIg4OZmRVxcDAzsyIO\nDmZmVsTBwczMijg4mJlZEQcHMzMr4uBgZmZFHBzMzKxI1c1+2t2ajYPeUMfMrEYdHRzWbBxk2arN\nDI+MAjA4NMyyVZsBHCDMzCro6Galleu2jgWGvOGRUVau2zpJOTIzaw8dHRxeHxquKd3MzHI6Ojgc\n09tTU7qZmeV0dHBYMv9Uerq7xqX1dHexZP6pk5QjM7P20NEd0vlOZ49WMjOrTabgIOki4B6gC3gg\nIlYUHF8I3AnsA/YCt0TEz1PHu4ABYDAiFhRc+2Xgm8DMiPjtBMpS0qJ5fQ4GZmY1qtqslPyw3wtc\nDJwOLJZ0esFpTwJzImIucD3wQMHxm4EXS9z7WOBC4LXas25mZs2Spc/hLGBbRGyPiPeAR4CF6RMi\n4u2IiOTjdCD/HkmzgEspDhgA3wZuS59vZmaTL0tw6AN2pj7vStLGkXS5pJeAteRqD3l3kwsA+wrO\nX0iumen5WjNtZmbN1bDRShGxOiJOAxaR639A0gJgd0RsSJ8r6VDgr4GvVruvpBskDUga2LNnT6Oy\na2ZmFWQJDoPAsanPs5K0kiLiaWC2pBnAucBlknaQa466QNJDwInACcDzybFZwP+R9G9L3O/+iOiP\niP6ZM2dmK5WZmU2I9ncVlDlBOgj4NfBJckFhPfDZiNiSOuck4JWICElnAt8HZqX6IZB0PvCVwtFK\nybEdQH+10UqS9gCvZitaU8wAGj6i6gDrhDJAZ5TDZWgNU6EMH4qImp6uqw5ljYi9km4C1pEbyvpg\nRGyRdGNy/D7gSuA6SSPAMHB1VIs6dai1cI0maSAi+iczDxPVCWWAziiHy9AaXIbSMs1ziIgngCcK\n0u5Lvf8G8I0q9/gp8NMyx47Pkg8zMzswOnr5DDMzq4+DQ23un+wMNEAnlAE6oxwuQ2twGUqo2iFt\nZmZTj2sOZmZWZEoHB0kXSdoqaZukpSWOL5T0gqRNyUS88wqOd0naKOkHqbQ7JA0m12ySdEm7lSFJ\n/5KklyRtkXRXu5VB0qOpP4Mdkja1YRnmSno2dc1ZbViGOZL+t6TNkr4v6YOtWobk78nm/LFU+hGS\nfizp5eT18DYsw1XJv+V9krKNaoqIKfkfuWG5rwCzgYOB54HTC855P/ub3j4CvFRw/K+A7wI/SKXd\nQW4+RzuX4RPAT4BDks9HtlsZCo5/C/hqu5UB+BFwcfL+EuCnbViG9cB/SN5fD9zZqmUAdgAzStz3\nLmBp8n4p8I02LMOfAKeSGzHanyUvU7nm0MwFBQ+UZpXhC8CKiHg3ucfuJuUfmvznIEnAZ4CHm5D3\nvGaVIYD8k/ZhwOtNyHtes8pwCvB08v7H5OZENcuEylDBQuA7yfvvkFsiqFmaUoaIeDEittaSkakc\nHJqyoGDiS0m178EmV0GbVYZTgI9Jek7SzyT9aWOzPU4z/xwAPga8EREvNya7JTWrDLcAKyXtJLfn\nybJGZrpAs8qwhf0/blcxfimeRptoGQL4iaQNkm5IpR8VEb9J3v8rcFRjsz1Os8pQs6kcHDKJGhYU\nTPwduSp2FCtfAAAB80lEQVThXOA35Jo0JlUdZTgIOAI4B1gCPJY8gU+aOsqQt5jm1hoyq6MMXwBu\njYhjgVuBfzxgmS2jjjJcD/wnSRuADwDvHbDMllGqDInzIrcnzcXAFyV9vMS1QQtsMTCRMmQ1lYND\nMxYUJCLeiIjRiNgH/AO5amKzNKUM5J5WVkXOL8g9Dc5oQv6heWXIrwt2BfBoE/Kd1qwyfA5Ylbz/\nZ9rw71JEvBQRF0bER8kF6VealH+YWBmIiMHkdTewmv3/v9+QdDRA8trMZtZmlaF2zepYafX/yD0d\nbye3Omy+4+fDBeecxP6OnzOTPyQVnHM+4zvgjk69vxV4pA3LcCPwN8n7U8hVc9VOZUjSLgJ+1sZ/\nl14Ezk/efxLY0IZlODJ5nQb8d+D6ViwDubb7DyTp04H/BVyUfF7J+A7pu9qtDKlrf0rGDulMayt1\nomjegoJ3SZpLruq5A/jLNizDg8CDkn5JrhngcxmuabUyAFzDAWhSamIZPg/ck9SA/ghMqA15ksqw\nWNIXk/ergH9qTgkmVgZJRwGrk9bTg4DvRsQPk1uvINe0+hfkVoX+TLuVQdLlwN8CM4G1kjZFxPxK\nefEMaTMzKzKV+xzMzKwMBwczMyvi4GBmZkUcHMzMrIiDg5mZFXFwMDOzIg4OZmZWxMHBzMyK/H+f\nxGbGZIn+BwAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"samples = []\n",
"for _ in range(100): # 100 samples\n",
" samples.append(pydoocs.read(\"FLASH.DIAG/TOROID.ML/*/CHARGE.FLASH1\")['data'])\n",
" time.sleep(0.1) # read-out with repetition rate of ~10Hz\n",
" \n",
"toroids = {element[4]: [] for element in samples[0]} # generate output dict with all toroids\n",
"for sample in samples: # fill output dict\n",
" for element in sample:\n",
" toroids[element[4]].append(element[1])\n",
" \n",
"plot(toroids[\"3GUN\"], toroids[\"1UBC3\"], 'o'); # just print two of them against each other"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The downside of this approach is that only works for one device. Synchronizing several devices would require memorizing and post-sorting the data utilizing the macropulse number. A better approach is to directly synchronize via the macropulse number as described below."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"### via macropulse number:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Synchronized readout via macropulse number can be achieved in the following way:"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1717296712 1717296712 0\n"
]
}
],
"source": [
"output1 = pydoocs.read(\"FLASH.DIAG/TOROID.ML/3GUN/CHARGE.FLASH1\")\n",
"time.sleep(2) # to simulate time lag between read calls in order to prevent intrinsic synchronization\n",
"output2 = pydoocs.read(\"FLASH.DIAG/TOROID.ML/3GUN/CHARGE.FLASH1\", \n",
" macropulse=output1[\"macropulse\"]) # providing the macropulse from the first call\n",
"\n",
"print(output2[\"macropulse\"], output1[\"macropulse\"], output2[\"macropulse\"] - output1[\"macropulse\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Without providing the macropulse from the first call, one would see a macropulse difference unequal 0 between the two calls:"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1717296752 1717296732 20\n"
]
}
],
"source": [
"output1 = pydoocs.read(\"FLASH.DIAG/TOROID.ML/3GUN/CHARGE.FLASH1\")\n",
"time.sleep(2)\n",
"output2 = pydoocs.read(\"FLASH.DIAG/TOROID.ML/3GUN/CHARGE.FLASH1\")\n",
"\n",
"print(output2[\"macropulse\"], output1[\"macropulse\"], output2[\"macropulse\"] - output1[\"macropulse\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Of course, synchronized readout via macropulse number works for different locations, which is also demonstrated by the correlation plot (cf. the plot from the wildcard method above)."
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1717296752 1717296752 0\n"
]
}
],
"source": [
"output1 = pydoocs.read(\"FLASH.DIAG/TOROID.ML/3GUN/CHARGE.FLASH1\")\n",
"time.sleep(2)\n",
"output2 = pydoocs.read(\"FLASH.DIAG/TOROID.ML/1UBC3/CHARGE.FLASH1\", macropulse=output1[\"macropulse\"])\n",
"\n",
"print(output2[\"macropulse\"], output1[\"macropulse\"], output2[\"macropulse\"] - output1[\"macropulse\"])"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAD8CAYAAACGsIhGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIQcLMzMr5GBhZmaF/j/TBPAIu3UCywAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"toroids = {\"3GUN\": [], \"1UBC3\": []}\n",
"for _ in range(100): # 100 samples\n",
" output = pydoocs.read(\"FLASH.DIAG/TOROID.ML/3GUN/CHARGE.FLASH1\")\n",
" toroids[\"3GUN\"].append(output[\"data\"])\n",
" \n",
" time.sleep(0.2) # to simulate time lag between read calls to prevent intrinsic synchronization\n",
" \n",
" output = pydoocs.read(\"FLASH.DIAG/TOROID.ML/1UBC3/CHARGE.FLASH1\", macropulse=output[\"macropulse\"])\n",
" toroids[\"1UBC3\"].append(output[\"data\"])\n",
" \n",
"plot(toroids[\"3GUN\"], toroids[\"1UBC3\"], 'o');"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In contrast to the wildcard approach, we can also synchronize different device:"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1717297167 1717297167 0\n"
]
}
],
"source": [
"output1 = pydoocs.read(\"FLASH.DIAG/TOROID.ML/3GUN/CHARGE.FLASH1\")\n",
"time.sleep(2)\n",
"try:\n",
" output2 = pydoocs.read(\"FLASH.DIAG/ORBIT/3GUN/X.FLASH1\", macropulse=output1[\"macropulse\"])\n",
" \n",
" print(output2[\"macropulse\"], output1[\"macropulse\"], output2[\"macropulse\"] - output1[\"macropulse\"])\n",
"except pydoocs.PyDoocsException as err:\n",
" print(err) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"However, when the synchronization in the DOOCS server is not working properly or the time lag between calls is too large, differences in the requested and actual macropulse can occur, which in turn leads to a 'macropulse mismatch' PyDoocsException."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"macropulse mismatch: (requested - actual) is -1\n"
]
}
],
"source": [
"output = pydoocs.read(\"FLASH.DIAG/TOROID.ML/3GUN/CHARGE.FLASH1\")\n",
"time.sleep(2)\n",
"try:\n",
" pydoocs.read(\"FLASH.DIAG/ORBIT/3GUN/X.FLASH1\", macropulse=output[\"macropulse\"])\n",
"except pydoocs.PyDoocsException as err:\n",
" print(err)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The DOOCS server support for synchronization via macropulse is currently very limited (see also [supported data types](#data-types) below), but this will certainly improve over time and with usage. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## Supported data types:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The data types and operations on them, as discussed throughout this introduction, currently supported:"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"| Data type | Read Support | Synchronization | Write Support | Write with Output |\n",
"|:----------:|:------------:|:---------------:|:-------------:|:-----------------:|\n",
"| BOOL | yes | no | yes | no |\n",
"| INT | yes | no | yes | no |\n",
"| LONG | yes | no | yes | no |\n",
"| FLOAT | yes | yes | yes | no |\n",
"| DOUBLE | yes | no | yes | no |\n",
"| STRING | yes | no | yes | yes |\n",
"| TEXT | yes | no | yes | no |\n",
"| IFFF | yes | no | yes | no |\n",
"| IIII | yes | no | yes | no |\n",
"| A_INT | yes | no | yes | no |\n",
"| A_LONG | yes | no | yes | no |\n",
"| A_FLOAT | yes | no | yes | no |\n",
"| A_DOUBLE | yes | no | yes | no |\n",
"| A_BYTE | yes | no | no | no |\n",
"| A_TS_FLOAT | yes | no | no | no |\n",
"| A_XYZS | yes | no | no | no |\n",
"| A_XY | yes | no | no | no |\n",
"| A_USTR | yes | no | no | no |\n",
"| A_TDS | yes | no | no | no |\n",
"| SPECTRUM | yes | yes | yes | no |\n",
"| GSPECTRUM | yes | no | no | no |\n",
"| IMAGE | yes | no | no | no |\n",
"| | | | | |\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## The API breaking differences compared to the previous pydoocs version:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### The old version has a 'channel' key, which has been removed in this new version, and the new version has an additional 'miscellaneous' key to store optional data in a dict (see also [read function](#read) above):"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"old version: \n",
"```\n",
"pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"BOOL\").keys()\n",
"dict_keys(['data', 'type', 'channel', 'timestamp', 'macropulse'])\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys(['data', 'type', 'timestamp', 'macropulse', 'miscellaneous'])"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"BOOL\").keys()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### The new version has no explicit 'numpy' keyword anymore, as it returns numpy array as a default whenever reasonable, e.g. for array types (see also [read function](#read) above):"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"old version:\n",
"```\n",
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"IMAGE\", numpy=True); type(output['data'])\n",
"numpy.ndarray\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"IMAGE\"); type(output['data'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### The new version either returns 'lists' or 'numpy.ndarrays' for non-skalar types as opposed to the old version, which returns 'tuples' or 'dicts' (see also [read function](#read) above):"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"old version: \n",
"```\n",
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"INTEGER_ARRAY\"); type(output['data'])\n",
"tuple\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"INTEGER_ARRAY\"); type(output['data'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"old version: \n",
"```\n",
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"IFFF_ARRAY\"); type(output['data'])\n",
"dict\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"list"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"output = pydoocs.read(TEST_SERVER_BASE_ADDRESS + \"IFFF_ARRAY\"); type(output['data'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### The 'OSError' exception in the old version has been replaced by the two custom exceptions DoocsException and PyDoocsException (see also [exceptions](#exceptions) above):"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"old version:
\n",
"```\n",
"try:\n",
" pydoocs.read(TEST_SERVER_BASE_ADDRESS)\n",
"except OSError as err:\n",
" print(err)\n",
"{'code': 101, 'message': 'illegal service'}\n",
"\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'code': 101, 'message': 'illegal service'}\n"
]
}
],
"source": [
"try:\n",
" pydoocs.read(TEST_SERVER_BASE_ADDRESS)\n",
"except pydoocs.DoocsException as err:\n",
" print(err)"
]
}
],
"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.6.1"
}
},
"nbformat": 4,
"nbformat_minor": 2
}