pytac_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial we will go through some of the most common ways of using pytac. The aim is to give you an understanding of the interface and how to find out what is available.\n",
    "\n",
    "# Loading the lattice\n",
    "\n",
    "The central object in pytac is the `lattice`. It holds the information about all of the elements in the accelerator.\n",
    "\n",
    "All the data about the lattice and its elements is stored in CSV files inside the pytac repository. We use the `load_csv` module to load the data and initialise a `lattice` object; this is the normal starting point for using pytac.\n",
    "\n",
    "The \"ring mode\" describes one configuration of the elements in the lattice. There is one set of CSV files for each ring mode. So when we load the lattice, we specify the ring mode we want to load.\n",
    "\n",
    "At the time of writing the normal ring mode in use at Diamond is \"DIAD\", so let's load that.\n",
    "\n",
    "First some required imports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, os\n",
    "# Make the pytac package available from this subdirectory\n",
    "sys.path.append(os.path.join(os.getcwd(), '..'))\n",
    "import pytac"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize the DIAD mode. The import of the Cothread channel access library will allow us to get some live values from the Diamond accelerators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cothread\n",
    "lattice = pytac.load_csv.load('DIAD')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The lattice object itself has some fields with its own properties:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'live': ['energy',\n",
       "  'tune_y',\n",
       "  'tune_x',\n",
       "  's_position',\n",
       "  'emittance_x',\n",
       "  'emittance_y',\n",
       "  'beam_current']}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lattice.get_fields()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The name \"live\" is referring to the data source - Pytac can also be set up with additional data sources for simulation, but that isn't described here.\n",
    "\n",
    "We can ask for the values of these fields. These commands will try to get the real values from the live machine (so won't work if you're not on a suitable Diamond network)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3000000000.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lattice.get_value(\"energy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "296.6981619696345"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lattice.get_value(\"beam_current\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Families, elements and fields\n",
    "\n",
    "The elements in the lattice are grouped by families, and this is the most common way to choose some to access. We can list the available families:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'AP',\n",
       " 'BB',\n",
       " 'BBVMXL',\n",
       " 'BBVMXS',\n",
       " 'BEND',\n",
       " 'BPM',\n",
       " 'BPM10',\n",
       " 'BUMP',\n",
       " 'BUMPSS',\n",
       " 'D054BA',\n",
       " 'D054BAL',\n",
       " 'D09_1',\n",
       " 'D09_10',\n",
       " 'D09_12',\n",
       " 'D09_13',\n",
       " 'D09_14',\n",
       " 'D09_2',\n",
       " 'D09_3',\n",
       " 'D09_5',\n",
       " 'D09_6',\n",
       " 'D09_7',\n",
       " 'D09_8',\n",
       " 'D09_9',\n",
       " 'D104BA0',\n",
       " 'D104BA0R',\n",
       " 'D104BA1',\n",
       " 'D104BAA',\n",
       " 'D104BAB',\n",
       " 'D104BAC',\n",
       " 'D104BAD',\n",
       " 'D104BAML',\n",
       " 'D104BAMR',\n",
       " 'D104BAR',\n",
       " 'D10_1',\n",
       " 'D10_2',\n",
       " 'D10_3',\n",
       " 'D10_4',\n",
       " 'D10_5',\n",
       " 'D10_6',\n",
       " 'D10_7',\n",
       " 'D10_8',\n",
       " 'D10_9',\n",
       " 'D13_1',\n",
       " 'D13_10',\n",
       " 'D13_12',\n",
       " 'D13_13',\n",
       " 'D13_14',\n",
       " 'D13_2',\n",
       " 'D13_3',\n",
       " 'D13_5',\n",
       " 'D13_6',\n",
       " 'D13_7',\n",
       " 'D13_8',\n",
       " 'D13_9',\n",
       " 'D154BAL',\n",
       " 'D154BAR',\n",
       " 'D1A',\n",
       " 'D1Aa',\n",
       " 'D1Ab',\n",
       " 'D1D2',\n",
       " 'D1M4BA',\n",
       " 'D1M4BAL1',\n",
       " 'D1M4BAL2',\n",
       " 'D1S4BA',\n",
       " 'D1X',\n",
       " 'D1Y',\n",
       " 'D1YAD1YA',\n",
       " 'D1YB',\n",
       " 'D20_1',\n",
       " 'D20_2',\n",
       " 'D2A',\n",
       " 'D2B',\n",
       " 'D2B4BA',\n",
       " 'D2XL',\n",
       " 'D2XR',\n",
       " 'D2YA',\n",
       " 'D2YB',\n",
       " 'D2YC',\n",
       " 'D3A',\n",
       " 'D3Aa',\n",
       " 'D3Ab',\n",
       " 'D3B',\n",
       " 'D3B4BA',\n",
       " 'D3B4BAR',\n",
       " 'D4A',\n",
       " 'D4Aa',\n",
       " 'D4Ab',\n",
       " 'D4B',\n",
       " 'D4B4BA0',\n",
       " 'D4Ba',\n",
       " 'D4Bb',\n",
       " 'D5B',\n",
       " 'D6B',\n",
       " 'D6B4BA0',\n",
       " 'D6Ba',\n",
       " 'D6Bb',\n",
       " 'DBPM',\n",
       " 'DHS4BA',\n",
       " 'DHS4BAL1',\n",
       " 'DHS4BAL2',\n",
       " 'DHS4BAR1',\n",
       " 'DHS4BAR2',\n",
       " 'DHS4BAR3',\n",
       " 'DI05',\n",
       " 'DK4BAS20',\n",
       " 'DK4BAS21',\n",
       " 'DK4BAS22',\n",
       " 'DK4BAS23',\n",
       " 'DLB4BAL',\n",
       " 'DLB4BAR',\n",
       " 'DLBM4BA0',\n",
       " 'DLBM4BA1',\n",
       " 'DLBM4BAL1',\n",
       " 'DLBM4BAL2',\n",
       " 'DMID4BAL1',\n",
       " 'DMID4BAL2',\n",
       " 'DMID4BAR1',\n",
       " 'DMID4BAR2',\n",
       " 'DRBM4BA2',\n",
       " 'DRBM4BAL1',\n",
       " 'DRBM4BAL2',\n",
       " 'DRBM4BAR1',\n",
       " 'DRBM4BAR2',\n",
       " 'DRIFT',\n",
       " 'DRIFT_DRIFT_S2A',\n",
       " 'DRIFT_S2A',\n",
       " 'DSEXT',\n",
       " 'Drift',\n",
       " 'HCHICA',\n",
       " 'HSTR',\n",
       " 'HTRIM',\n",
       " 'HU64',\n",
       " 'KD1',\n",
       " 'MPW12',\n",
       " 'MPW15',\n",
       " 'MPW45',\n",
       " 'PAD',\n",
       " 'Q1AB',\n",
       " 'Q1AD',\n",
       " 'Q1B',\n",
       " 'Q1BE',\n",
       " 'Q1D',\n",
       " 'Q2AB',\n",
       " 'Q2AD',\n",
       " 'Q2B',\n",
       " 'Q2BE',\n",
       " 'Q2D',\n",
       " 'Q3B',\n",
       " 'Q3D',\n",
       " 'Q3E',\n",
       " 'Q4E',\n",
       " 'QM09',\n",
       " 'QM13',\n",
       " 'QUAD',\n",
       " 'RF',\n",
       " 'S1A',\n",
       " 'S1B',\n",
       " 'S1BE',\n",
       " 'S1C',\n",
       " 'S1D',\n",
       " 'S2A',\n",
       " 'S2B',\n",
       " 'S2BE',\n",
       " 'S2C',\n",
       " 'S2D',\n",
       " 'S3E',\n",
       " 'S4E',\n",
       " 'SEXT',\n",
       " 'SPACER',\n",
       " 'SQUAD',\n",
       " 'TEMPDRIFT',\n",
       " 'U21',\n",
       " 'U23a',\n",
       " 'U23b',\n",
       " 'U27',\n",
       " 'VSTR',\n",
       " 'VTRIM',\n",
       " 'shim',\n",
       " 'source'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lattice.get_all_families()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's get all the beam position monitors (BPMs). We do this by using get_elements which takes an argument for family name - in this case we use the family name \"BPM\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got 173 BPMs\n"
     ]
    }
   ],
   "source": [
    "bpms = lattice.get_elements('BPM')\n",
    "print(\"Got {} BPMs\".format(len(bpms)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at what we can find out about a single BPM.\n",
    "\n",
    "Each one has some fields:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'live': ['y_sofb_disabled',\n",
       "  'enabled',\n",
       "  'y',\n",
       "  'x',\n",
       "  'x_fofb_disabled',\n",
       "  'x_sofb_disabled',\n",
       "  'y_fofb_disabled']}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_bpm = bpms[0]\n",
    "one_bpm.get_fields()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fields represent a property of the BPM that can change. For example, x and y are the measured positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.047219"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_bpm.get_value(\"x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Devices\n",
    "\n",
    "Each field has a `device` object associated with it, which knows how to set and get the value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pytac.device.EpicsDevice at 0x7f4290a71f10>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_bpm.get_device(\"x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `device` object knows the PV names for reading and writing the value of the field. Each field might have a \"setpoint\" or \"readback\" handle, which could be associated with different PV names.\n",
    "\n",
    "You can use either strings or pytac constants to specify which handle to use. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('SR01C-PC-HBPM-01:SLOW:DISABLED', 'SR01C-PC-HBPM-01:SLOW:DISABLED')\n"
     ]
    }
   ],
   "source": [
    "readback_pv = one_bpm.get_pv_name(\"x_sofb_disabled\", \"readback\")\n",
    "same_readback_pv = one_bpm.get_pv_name(\"x_sofb_disabled\", pytac.RB)\n",
    "print(readback_pv, same_readback_pv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some fields are read-only, in which case there is no setpoint PV to get."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device SR01C-DI-EBPM-01 has no setpoint PV.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    one_bpm.get_pv_name(\"x_sofb_disabled\", pytac.SP)\n",
    "except Exception as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's not normally necessary to interact with the `device` directly; you can do most things through methods of the `element` or `lattice`. E.g. element.get_value() above and `lattice.get_element_pv_names`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['SR01C-DI-EBPM-01:SA:Y',\n",
       " 'SR01C-DI-EBPM-02:SA:Y',\n",
       " 'SR01C-DI-EBPM-03:SA:Y',\n",
       " 'SR01C-DI-EBPM-04:SA:Y',\n",
       " 'SR01C-DI-EBPM-05:SA:Y',\n",
       " 'SR01C-DI-EBPM-06:SA:Y',\n",
       " 'SR01C-DI-EBPM-07:SA:Y',\n",
       " 'SR02C-DI-EBPM-01:SA:Y',\n",
       " 'SR02C-DI-EBPM-02:SA:Y',\n",
       " 'SR02C-DI-EBPM-03:SA:Y']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lattice.get_element_pv_names('BPM', 'y', 'readback')[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unit conversions\n",
    "\n",
    "Many fields can be represented in either engineering units or physics units. For example, for a magnet field, the physics unit would be the field strength and the engineering unit would be the current applied by the magnet power supply controller."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.0552401542663574"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get a corrector magnet\n",
    "corrector = lattice.get_elements(\"HSTR\")[5]\n",
    "# Request\n",
    "corrector.get_value(\"x_kick\", units=pytac.ENG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to get the unit itslef, we have to ask for the `unitconv` object associated with the field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "corrector.get_unitconv(\"x_kick\").eng_units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Magnet fields\n",
    "\n",
    "This seems like a good time to talk about the names for the magnetic fields of magnets.\n",
    "\n",
    "In accelerator physics we refer to the different components of magnetic fields as $a_n$ for vertical fields and $b_n$ for horizontal fields, where n is:\n",
    "\n",
    "| n   | Field      |\n",
    "|-----|------------|\n",
    "| 0   | Dipole     |\n",
    "| 1   | Quadrupole |\n",
    "| 2   | Sextupole  |\n",
    "| ... | ...        |\n",
    "\n",
    "These names are used for the `field`s associated with magnet `element`s in pytac.\n",
    "\n",
    "For corrector magnets, although the corrector field acts like a dipole, it is given the name `x_kick` or `y_kick` so that it can be easily distinguished. An example of this is when several magnets are combined into the same `element`. The following example shows an element which combines a corrector, a skew quadrupole and a sextupole."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Fields:', {'live': ['h_fofb_disabled', 'h_sofb_disabled', 'v_fofb_disabled', 'a1', 'x_kick', 'v_sofb_disabled', 'b2', 'y_kick']})\n",
      "('Families:', set(['S4E', 'SQUAD', 'SEXT', 'VSTR', 'HSTR']))\n"
     ]
    }
   ],
   "source": [
    "an_element = lattice.get_elements(\"HSTR\")[12]\n",
    "print(\"Fields:\", an_element.get_fields())\n",
    "print(\"Families:\", an_element.families)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other methods of the `lattice`\n",
    "\n",
    "To finish off for now, let's look at some more of the methods of the `lattice`\n",
    "\n",
    "`lattice.get_element_values` lets you get all the live values for a field from a while family of elements. E.g. the currents for the horizontal corrector magnets. There is also an analogous command `lattice.set_element_values()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-0.24839822947978973,\n",
       " 0.7639292478561401,\n",
       " -0.4572945237159729,\n",
       " -0.1370551735162735,\n",
       " 0.6560376882553101,\n",
       " -3.0552401542663574,\n",
       " 3.0576119422912598,\n",
       " 0.6859914660453796,\n",
       " -0.8835821747779846,\n",
       " 0.37336450815200806,\n",
       " -0.397186279296875,\n",
       " -0.3592968285083771,\n",
       " 1.5479310750961304,\n",
       " -0.2497788667678833,\n",
       " -0.3833305537700653,\n",
       " 0.04267336428165436,\n",
       " 0.387008398771286,\n",
       " 2.083509922027588,\n",
       " -2.213555335998535,\n",
       " 2.316075086593628,\n",
       " -1.2140284776687622,\n",
       " 0.4225691556930542,\n",
       " -0.3863433301448822,\n",
       " 0.1559593677520752,\n",
       " 2.3147804737091064,\n",
       " -0.2917431592941284,\n",
       " -1.003007173538208,\n",
       " 0.5435793995857239,\n",
       " -0.21308128535747528,\n",
       " 0.30097678303718567,\n",
       " 0.42939627170562744,\n",
       " 2.6342201232910156,\n",
       " -3.1828463077545166,\n",
       " 1.8283201456069946,\n",
       " -0.6628888845443726,\n",
       " 0.1967700868844986,\n",
       " -0.15570154786109924,\n",
       " -0.08124255388975143,\n",
       " -0.09838544577360153,\n",
       " 1.190570592880249,\n",
       " -0.9167197346687317,\n",
       " -1.0333651304244995,\n",
       " 0.20847293734550476,\n",
       " -0.26976802945137024,\n",
       " 0.3439919054508209,\n",
       " 1.0685083866119385,\n",
       " -0.26988404989242554,\n",
       " -0.2225686013698578,\n",
       " 0.48204877972602844,\n",
       " 0.4525769352912903,\n",
       " -0.32029491662979126,\n",
       " 0.011995009146630764,\n",
       " -0.072536900639534,\n",
       " -0.7957542538642883,\n",
       " 1.8488221168518066,\n",
       " -1.8276989459991455,\n",
       " 2.074706554412842,\n",
       " -0.6961939930915833,\n",
       " 1.660825252532959,\n",
       " 2.037513256072998,\n",
       " -1.9940599203109741,\n",
       " 1.2870264053344727,\n",
       " 1.1285380125045776,\n",
       " -3.115408420562744,\n",
       " -0.6366449594497681,\n",
       " 0.6396395564079285,\n",
       " 0.1271335333585739,\n",
       " 0.5475709438323975,\n",
       " -1.7670093774795532,\n",
       " 1.6561113595962524,\n",
       " -1.3666211366653442,\n",
       " -1.5977840423583984,\n",
       " 0.5970470905303955,\n",
       " 0.5569626688957214,\n",
       " -0.061939679086208344,\n",
       " -2.2024006843566895,\n",
       " 1.2349647283554077,\n",
       " -1.1097846031188965,\n",
       " 0.21210838854312897,\n",
       " -0.9944986701011658,\n",
       " 1.2641316652297974,\n",
       " -0.4769899547100067,\n",
       " 0.9592297673225403,\n",
       " -1.6858210563659668,\n",
       " -0.542770266532898,\n",
       " 0.5003483891487122,\n",
       " 0.20877952873706818,\n",
       " -6.958314418792725,\n",
       " 1.8476916551589966,\n",
       " -1.3825221061706543,\n",
       " -0.3401913046836853,\n",
       " 0.03160438686609268,\n",
       " 1.2040449380874634,\n",
       " -1.0675880908966064,\n",
       " 1.0701864957809448,\n",
       " 0.6834375858306885,\n",
       " -1.2668933868408203,\n",
       " -0.07783783972263336,\n",
       " -0.39933741092681885,\n",
       " 1.5456103086471558,\n",
       " -0.3358473777770996,\n",
       " 0.1989932656288147,\n",
       " -0.20524908602237701,\n",
       " 0.1039108857512474,\n",
       " 0.5607045292854309,\n",
       " -0.6076611280441284,\n",
       " 0.6814919114112854,\n",
       " -1.242967128753662,\n",
       " 0.1817963421344757,\n",
       " -0.6134481430053711,\n",
       " 1.304316759109497,\n",
       " -1.8899571895599365,\n",
       " 3.616405963897705,\n",
       " -4.558992385864258,\n",
       " 0.129770427942276,\n",
       " 0.07601836323738098,\n",
       " 0.10492631047964096,\n",
       " 0.4832989573478699,\n",
       " 0.9280765652656555,\n",
       " -2.44914174079895,\n",
       " 2.768791913986206,\n",
       " -1.5745543241500854,\n",
       " 0.8972594141960144,\n",
       " -0.5179362297058105,\n",
       " 0.3355884850025177,\n",
       " -1.5213912725448608,\n",
       " 1.8749045133590698,\n",
       " -1.0240871906280518,\n",
       " -0.010050266981124878,\n",
       " -0.20131799578666687,\n",
       " 0.532402515411377,\n",
       " -0.4071364104747772,\n",
       " -2.65728759765625,\n",
       " 3.989853858947754,\n",
       " -3.6086249351501465,\n",
       " -0.3485717475414276,\n",
       " 0.2619762420654297,\n",
       " 0.13016314804553986,\n",
       " 0.08971194922924042,\n",
       " 0.22305065393447876,\n",
       " -0.17202238738536835,\n",
       " 0.0707668885588646,\n",
       " -0.03778775408864021,\n",
       " -0.031766898930072784,\n",
       " 0.14996331930160522,\n",
       " 0.04967852309346199,\n",
       " -2.149498701095581,\n",
       " 1.9415940046310425,\n",
       " -1.6292657852172852,\n",
       " -0.6792949438095093,\n",
       " 0.6019706726074219,\n",
       " 0.510526180267334,\n",
       " -0.009603044018149376,\n",
       " -2.642376184463501,\n",
       " 2.5861854553222656,\n",
       " -3.7314720153808594,\n",
       " -0.18924900889396667,\n",
       " 0.4994497001171112,\n",
       " 0.33791583776474,\n",
       " -0.35369110107421875,\n",
       " -1.1990420818328857,\n",
       " 2.3036105632781982,\n",
       " -2.647069215774536,\n",
       " -0.655612587928772,\n",
       " 0.9581286311149597,\n",
       " 0.14957129955291748,\n",
       " -1.030884027481079,\n",
       " 2.295074939727783,\n",
       " -0.5442541241645813,\n",
       " -1.0026730298995972,\n",
       " 0.33420810103416443,\n",
       " -0.2033674269914627]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lattice.get_element_values(\"HSTR\", \"x_kick\", \"readback\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`s` position is the position of an element in metres around the ring.\n",
    "\n",
    "There is a method to get the `s` positions of all elements in a family:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4.38,\n",
       " 8.806500000000002,\n",
       " 11.374000000000002,\n",
       " 12.559000000000005,\n",
       " 14.942500000000006,\n",
       " 18.005000000000003,\n",
       " 21.270000000000003,\n",
       " 26.93,\n",
       " 30.360759,\n",
       " 32.076129]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lattice.get_family_s(\"BPM\")[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}