Training

[TeresiaOlsson]

On the workshop in Berlin there was a quick discussion about training needs. This is the list of topics that was suggested:

• Metadata + standards
• Python
• Git + advanced git
• Accelerator physics → understand the basic algorithms, maybe could make use of CAS
• Web applications
• Graphical user interfaces
• Databases
• Control system basics
• pyAT

Does anyone have suggestions for topics that should be added to the list?

[gubaidulinvadim]

How are the trainings foreseen to be organised? Back in February, when the workshop was held, it was assumed that we would get the COST funding for these activities. We could think of something for the workshop at SOLEIL, but it has not yet been previewed.

[TeresiaOlsson]

I think that is also an important part to discuss. For training where the target audience is people who already are involved in the project doing it as part of a workshop is likely the best idea. But then we also have all the people who are pure users who likely will never go to a pyAML workshop.

I was thinking that perhaps some things can be done as fully remote workshops? Then cost would be small and easier for many people to join from around the world.

[yhidaka]

May I request a quick tutorial / discussion on how Tango works?

I'm not requesting a formal, detailed training (though that would be nice, too). Maybe one of the virtual meetings could be converted for this purpose? From what I saw in Jean-Luc's example configuration, I am confused about how Tango is being used. I'd like to learn rather quickly the main differences between Tango and EPICS such that I can think about how to make pyAML control system agnostic. I believe anyone else familiar with EPICS only can also benefit from this.

[TeresiaOlsson]

Me too. And then there is also DOOCS at DESY which I know nothing about but has to be supported early on.

Feels like it would be really useful with a session for the maintainers to go through the differences between the control systems.

[JeanLucPons]

We wrote very quicly a tango binding for pyTAC. pyTAC is originaly based on EPICS and offers a nice way to add other control systems. Unfortunately i don't remember where I put this code that I sent to @simoneliuzzo during the exploration phase. Simone could you share this file ? This bindings does not support arrays and has to be improved but works.

@swhite2401 wrote also a more ellaborated Tango bindings for pyACAL which support arrays.

I have no knowledge at all about DOOCS.

[simoneliuzzo]

Dear @JeanLucPons,

below the tango binding for pyTAC I fund in my files.

@TeresiaOlsson, @yhidaka, I like the idea of some training/dedicate meetings on the different control systems that we will work with.
@gubaidulinvadim for the workshop we will be able to ask LEAPS for some finances, as for the past workshops. Should I ask?

best regards
Simone

import logging

from tango import *
from math import nan

from pytac.cs import ControlSystem
from pytac.exceptions import ControlSystemException


class TangoControlSystem(ControlSystem):
    """A control system using cothread to communicate with Tango.

    N.B. this is the default control system. It is used to communicate over
    channel access with the hardware in the ring.

    **Methods:**
    """

    def __init__(self, timeout=1.0, wait=False):
        self._timeout = timeout
        self._wait = wait

    def get_single(self, pv, throw=True):
        """Get the value of a given PV.

        Args:
            pv (string): The process variable given as a string. It can be a
                         readback or a setpoint PV.
            throw (bool): On failure: if True, raise ControlSystemException; if
                           False, return None and log a warning.

        Returns:
            object: the current value of the given PV.

        Raises:
            ControlSystemException: if it cannot connect to the specified PV.
        """
        try:
            field = pv.split("/")
            dev = DeviceProxy(field[0]+"/"+field[1]+"/"+field[2])
            dev.set_timeout_millis(int(self._timeout*1000))
            att = dev.read_attribute(field[3])
            return att.w_value
        except DevFailed as err:
            error_msg = f"{pv}: {err}."
            if throw:
                raise ControlSystemException(error_msg)
            else:
                logging.warning(error_msg)
                return None

    def get_multiple(self, pvs, throw=True):
        """Get the value for given PVs.

        Args:
            pvs (sequence): PVs to get values of.
            throw (bool): On failure: if True, raise ControlSystemException; if
                           False, None will be returned for any PV that fails
                           and a warning will be logged.

        Returns:
            sequence: the current values of the PVs.

        Raises:
            ControlSystemException: if it cannot connect to one or more PVs.
        """
        return_values = []
        failures = 0
        for pv in pvs:
              print(pv)
              att = self.get_single(pv,False)
              if att is None:
                  failures = failures + 1
                  return_values.append(nan)
              else:
                  return_values.append(att)
        if throw and failures>0:
            raise ControlSystemException(f"{failures} calls failed.")
        return return_values

    def set_single(self, pv, value, throw=True):
        """Set the value of a given PV.

        Args:
            pv (string): PV to set the value of.
            value (object): The value to set the PV to.
            throw (bool): On failure: if True, raise ControlSystemException: if
                           False, log a warning.

        Returns:
            bool: True for success, False for failure

        Raises:
            ControlSystemException: if it cannot connect to the specified PV.
        """
        try:
            field = pv.split("/")
            dev = DeviceProxy(field[0] + "/" + field[1] + "/" + field[2])
            dev.set_timeout_millis(self._timeout * 1000.0)
            dev.write_attribute(field[3],value)
            return True
        except DevFailed as err:
            error_msg = f"{pv}: {err}."
            if throw:
                raise ControlSystemException(error_msg)
            else:
                logging.warning(error_msg)
                return False

    def set_multiple(self, pvs, values, throw=True):
        """Set the values for given PVs.

        Args:
            pvs (sequence): PVs to set the values of.
            values (sequence): values to set to the PVs.
            throw (bool): On failure, if True raise ControlSystemException, if
                           False return a list of True and False values
                           corresponding to successes and failures and log a
                           warning for each PV that fails.

        Returns:
            list(bool): True for success, False for failure; only returned if
                         throw is false and a failure occurs.

        Raises:
            ValueError: if the lists of values and PVs are diffent lengths.
            ControlSystemException: if it cannot connect to one or more PVs.
        """
        if len(pvs) != len(values):
            raise ValueError("Please enter the same number of values as attributes.")

        return_values = []
        failures = 0
        for pv,idx in enumerate(pvs):
              att = self.set_single(pv,values[idx],False)
              if att is None:
                  failures = failures + 1
                  return_values.append(nan)
              else:
                  return_values.append(att)
        if throw and failures>0:
            raise ControlSystemException(f"{failures} calls failed.")
        return return_values

[TeresiaOlsson]

@kparasch @iagapov Do you perhaps have someone from DESY that you think could be interested in giving a quick introduction to DOOCS if we make a meeting/training for the maintainers dedicated to learning about the three control systems we need to support?

[kparasch]

I will see if we can find someone but I cannot guarantee it. Do you think the training should cover how the servers are structured or have just the client's point of view?

In any case, I can take care of the DOOCS bindings.

[JeanLucPons]

Thanks Kostas for the proposal, it's cool that you can handle the DOOCS bindings.
We have to define where we will put all bindings for Tango,EPICS,DOOCS ? It could be nice to have all them on this repo.
Concerning the DOOCS training, I think client side only is ok.

[JeanLucPons]

Thanks @simoneliuzzo , it is the good file.

[TeresiaOlsson]

The steering committee discussed and decided two things:

1. To make the control system training at the next community zoom meeting. This will be in September. I'm responsible for putting together the agenda so I will attempt to find speakers. I was thinking perhaps to first ask people who aren't already among the maintainers to spread the workload and also involve the community in the community meeting?

2. To provide pyAT training to help people to start moving from matlab AT. @simoneliuzzo said this training already exists and is ready to go. I think we in addition also need some basic github training so people can learn how to contribute to pyAT if they have functionality in matlab AT that they need. The idea is to run it in hybrid in connection with the next workshop. @lnadolski said he will discuss options with @gubaidulinvadim considering time zones etc. If it doesn't work I think it can also be done fully remote.