def get_time_stamped_data():
sample_time = 0.50
num_to_show = 5
gdet = Pv('GDET:FEE1:241:ENRC')
gmd = Pv('SXR:GMD:BLD:milliJoulesPerPulse')
ebeam = Pv('BLD:SYS0:500:PHOTONENERGY')
pv_list = [gdet, gmd, ebeam]
for pv in pv_list:
pv.monitor_start(True)
time.sleep(sample_time)
for pv in pv_list:
pv.monitor_stop()
my_dict = {}
for pv in pv_list:
for my_timestamps, my_vals in zip(pv.timestamps, pv.values):
if ts_to_fid(my_timestamps) in my_dict:
my_dict[ts_to_fid(my_timestamps)][pv.name] = my_vals
else:
my_dict[ts_to_fid(my_timestamps)] = {pv.name: my_vals}
my_array = np.array([
np.array([my_dict[i][j] for j in my_dict[i]]) for i in my_dict
if len(my_dict[i]) == 3
]).transpose()
return my_array
def __init__(self, name):
pycaPv.__init__(self, name)
self.connect(time_out_connect)
self.monitor_cb = self.monitor_handler
self.values = []
self.ismonitored = False
self.last_update = "Never"
def connect(self):
Pv.connect(self, timeout=1.0)
self.connected = True
# self.monitor_cb = self.changed
evtmask = pyca.DBE_VALUE | pyca.DBE_LOG | pyca.DBE_ALARM
self.monitor(evtmask)
pyca.flush_io()
def __init__(self, name, adata=None):
Pv.__init__(self, name)
self.connected = False
self._name = name
self.evt = threading.Event()
if adata != None:
self.set_processor(adata)
self.connect()
def __init__(self, pv_camera, pv_x, pv_z, detector=Detector()):
self.pv_obj_camera = Pv(pv_camera)
self.pv_obj_x = Pv(pv_x)
self.pv_obj_z = Pv(pv_z)
self.detector = detector
self.image = None
self.centroid = None
self.bounding_box = None
def caput(pvname, value, timeout=1.0):
try:
pv = Pv(pvname)
pv.connect(timeout)
pv.get(ctrl=False, timeout=timeout)
pv.put(value, timeout)
pv.disconnect()
except pyca.pyexc, e:
print 'pyca exception: %s' % (e)
def setup_pv(pvname, con_cb=None, mon_cb=None, rwaccess_cb=None, signal=None, mon_cb_once=False):
"""
Initialize an EPICS PV using psp with proper callbacks.
:param pvname: EPICS PV name
:type pvname: str
:param con_cb: Connection callback. If left as None and provided with
signal, emit our value from signal as the callback.
:type con_cb: function(isconnected=None)
:param mon_cb: Monitor callback. If left as None and provided with signal,
emit our value from signal as the callback.
:type mon_cb: function(errors=None)
:param rwaccess_cb: Read/write access state callback.
:type rwaccess_cb: function(access_state)
:param signal: Signal to emit our value on as the default callback when
con_cb or mon_cb are left as None. Check the base
:class:`PyDMConnection` class for available signals.
:type signal: Signal
:param mon_cb_once: True if we only want the monitor callback to run once.
:type mon_cb_once: bool
:rtype: Pv
"""
pv = Pv(pvname, use_numpy=True)
if signal is None:
default_mon_cb = lambda e: None
else:
default_mon_cb = generic_mon_cb(pv, signal)
pv.add_connection_callback(con_cb or generic_con_cb(pv))
pv.add_monitor_callback(mon_cb or default_mon_cb, once=mon_cb_once)
if rwaccess_cb:
pv.add_rwaccess_callback(rwaccess_cb)
pv.connect(None)
return pv
def connectPv(name, timeout=-1.0):
try:
pv = Pv(name)
if timeout < 0:
pv.save_connect_cb = pv.connect_cb
pv.connect_cb = lambda isconn: __connect_callback(pv, isconn)
pv.connect(timeout)
else:
pv.connect(timeout)
pv.get(ctrl=False, timeout=timeout)
return pv
except:
return None
def dopv(self, name, gui, format):
pv = Pv(name, initialize=True)
if pv != None:
gui.setText("")
pv.gui = gui
pv.format = format
self.pvlist.append(pv)
pv.add_monitor_callback(lambda e: self.displayPV(pv, e))
try:
pv.wait_ready(0.5)
pv.monitor()
except:
pass
def setup_pv(pvname, con_cb=None, mon_cb=None, signal=None, mon_cb_once=False):
"""
Initialize an EPICS PV using psp with proper callbacks.
:param pvname: EPICS PV name
:type pvname: str
:param con_cb: Connection callback. If left as None and provided with
signal, emit our value from signal as the callback.
:type con_cb: function(isconnected=None)
:param mon_cb: Monitor callback. If left as None and provided with signal,
emit our value from signal as the callback.
:type mon_cb: function(errors=None)
:param signal: Signal to emit our value on as the default callback when
con_cb or mon_cb are left as None. Check the base
:class:`PyDMConnection` class for available signals.
:type signal: pyqtSignal
:param mon_cb_once: True if we only want the monitor callback to run once.
:type mon_cb_once: bool
:rtype: Pv
"""
pv = Pv(pvname, use_numpy=True)
if signal is None:
default_mon_cb = lambda e: None
else:
default_mon_cb = generic_mon_cb(pv, signal)
pv.add_connection_callback(con_cb or generic_con_cb(pv))
pv.add_monitor_callback(mon_cb or default_mon_cb, once=mon_cb_once)
pv.connect(None)
return pv
def get(self, handle_no_ioc=True):
""" returns current value for the Pv """
if (is_debug_on()):
logprint("caget %s: " % self.name)
try:
pycaPv.get(self, False, time_out_get)
self.last_update = self.timestr()
if (is_debug_on()):
logprint("got %s\n" % self.value.__str__())
return self.value
except pyca.pyexc:
logprint("caget %s: " % self.name, newline=False)
logprint("failed (PV timed out) !!, returning nan")
return numpy.nan
def __init__(self,
motor_channel,
motor_name=None,
active_monitoring=False):
self.motor_channel = motor_channel
self.motor_name = motor_name
self.active_monitoring = active_monitoring
self.__move_pv = Pv(motor_channel)
self.__move_pv.connect(1.0)
# self.__pos_pv = Pv(self.__get_pv_name('.RBV'))
# self.__pos_pv.connect(1.0)
self.__dmovpv = Pv(self.__get_pv_name('.DMOV'))
self.update()
pass
def __init__(self, name):
pycaPv.__init__(self, name)
try:
self.connect(time_out_connect)
except pyca.pyexc:
print "## WARNING ## connecting to %s timeout, will try once more" % name
logprint(
"## WARNING ## connecting to %s timeout, will try once more" %
name)
time.sleep(0.1)
self.connect(time_out_connect)
self.monitor_cb = self.monitor_handler
self.values = []
self.ismonitored = False
self.monitor_append = False
self.last_update = "Never"
def caget(pvname, timeout=1.0):
try:
pv = Pv(pvname)
pv.connect(timeout)
pv.get(ctrl=False, timeout=timeout)
v = pv.value
pv.disconnect()
return v
except pyca.pyexc, e:
print 'pyca exception: %s' % (e)
return None
def caget(pvname, timeout=1.0, **kw):
try:
pv = Pv(pvname)
pv.connect(timeout)
try:
if kw['enum']:
pv.set_string_enum(True)
except:
pass
pv.get(ctrl=False, timeout=timeout)
v = pv.value
pv.disconnect()
return v
except pyca.pyexc as e:
print('pyca exception: %s' % (e))
return None
except pyca.caexc as e:
print('channel access exception: %s' % (e))
return None
class Imager(object):
"""
Imager object that will encapsulate the various yag screens along the
beamline.
"""
def __init__(self, pv_camera, pv_x, pv_z, detector=Detector()):
self.pv_obj_camera = Pv(pv_camera)
self.pv_obj_x = Pv(pv_x)
self.pv_obj_z = Pv(pv_z)
self.detector = detector
self.image = None
self.centroid = None
self.bounding_box = None
def get(self):
"""Get an image from the imager."""
self.image = Pv.get()
return self.image
def get_centroid(self):
"""Return the centroid of the image."""
self.centroid, self.bounding_box = self.detector.find(Pv.get())
return self.centroid
@property
def x(self):
return self.pv_obj_x.get()
@x.setter
def x(self, val):
put_val(self.pv_obj_x, val)
@property
def z(self):
return self.pv_obj_z.get()
@z.setter
def z(self, val):
put_val(self.pv_obj_z, val)
@property
def pos(self):
return np.array([self.pv_obj_z.get(), self.pv_obj_x.get()])
class Source(object):
def __init__(self, pv_x, pv_xp, pv_y, pv_yp, pv_z):
self.pv_obj_x = Pv(pv_x)
self.pv_obj_xp = Pv(pv_xp)
self.pv_obj_y = Pv(pv_y)
self.pv_obj_yp = Pv(pv_yp)
self.pv_obj_z = Pv(pv_z)
def put_val(self, pv, val):
try:
pv.put(float(val))
except ValueError:
print("Invalid input type. Must be castable to float.")
@property
def x(self):
return self.pv_obj_x.get()
@x.setter
def x(self, val):
put_val(self.pv_obj_x, val)
@property
def xp(self):
return self.pv_obj_xp.get()
@xp.setter
def xp(self, val):
put_val(self.pv_obj_xp, val)
@property
def y(self):
return self.pv_obj_y.get()
@y.setter
def y(self, val):
put_val(self.pv_obj_y, val)
@property
def yp(self):
return self.pv_obj_yp.get()
@yp.setter
def yp(self, val):
put_val(self.pv_obj_yp, val)
@property
def z(self):
return self.pv_obj_z.get()
@z.setter
def z(self, val):
put_val(self.pv_obj_z, val)
@property
def pos(self):
return np.array([self.pv_obj_z.get(), self.pv_obj_x.get()])
class LclsEvent(object):
"""
Contains methods to view and change parameters from the lcls
event/timing system screen.
"""
def __init__(self):
self._bykik_abort_pv = Pv(ioc_base + "BYKIK_ABTACT")
self._bykik_period_pv = Pv(ioc_base + "BYKIK_ABTPRD")
def edm_screen(self):
"""
Open up the lcls event/timing screen.
"""
subprocess.Popen([
"sh",
"/reg/g/pcds/package/epics/3.14-dev/screens/edm/common/current/lcls/lclsSystemArea.sh"
])
def bykik_status(self):
"""
Return status of bykik abort (Disable or Enable)
"""
val = self._bykik_abort_pv.get()
if val == 0:
return "Disable"
else:
return "Enable"
def bykik_disable(self):
"""
Disable bykik abort
"""
self._bykik_abort_pv.put(0)
def bykik_enable(self):
"""
Enable bykik abort
"""
self._bykik_abort_pv.put(1)
def bykik_get_period(self):
"""
Get number of events between bykik aborts
"""
return self._bykik_period_pv.get()
def bykik_set_period(self, period):
"""
Set number of events between bykik aborts
"""
self._bykik_period_pv.put(period)
def caPutArray(pvName, value, timeout=-1.0):
try:
tmo = float(timeout)
# See if this PV exists
pv = Pv(pvName)
pv.connect(1.0)
# Convert value to the appropriate type for this PV
# Assumption is that PV is a waveform record
if isinstance(value, str):
# Convert string values to a tuple
value = stringToTuple(value)
if not isinstance(value, tuple):
raise TypeError, "Pv.put Error: value not a tuple for waveform PV"
if len(value) != len(pv.value):
raise TypeError, "Pv.put Error: Element count mismatch"
pv.put_data(value, tmo)
except Exception, msg:
if verbose:
print "Unable to connect to PV:", pvName
if showCAErrors:
print >> sys.stderr, "failed: pyca exception: ", msg
return
def caget(pvname,timeout=30.0):
try:
pv = Pv(pvname)
pv.connect(timeout)
pv.get(ctrl=False, timeout=timeout)
v = pv.value
pv.disconnect()
return v
except pyca.pyexc as e:
print('pyca exception: %s' %(e))
return None
except pyca.caexc as e:
print('channel access exception: %s' %(e))
return None
def caget_async(pvname):
try:
pv = Pv(pvname)
pv.get_done = threading.Event()
pv.connect_cb = lambda isconn: __connect_callback(pv, isconn)
pv.getevt_cb = lambda e=None: __get_callback(pv, e)
pv.connect(-1)
return pv
except pyca.pyexc, e:
print 'pyca exception: %s' % (e)
return None
class Mirror(object):
"""
Mirror class to encapsulate the two HOMS (or any) mirrors.
"""
def __init__(self, pv_x, pv_alpha, pv_z):
self.pv_obj_x = Pv(pv_x)
self.pv_obj_xp = Pv(pv_xp)
self.pv_obj_z = Pv(pv_z)
@property
def x(self):
return self.pv_obj_x.get()
@x.setter
def x(self, val):
put_val(self.pv_obj_x, val)
@property
def alpha(self):
return self.pv_obj_alpha.get()
@alpha.setter
def alpha(self, val):
put_val(self.pv_obj_alpha, val)
@property
def z(self):
return self.pv_obj_z.get()
@z.setter
def z(self, val):
put_val(self.pv_obj_z, val)
@property
def pos(self):
return np.array([self.pv_obj_z.get(), self.pv_obj_x.get()])
def reconfigStream(cameraPvName, streamName, verbose=False):
streamPvName = cameraPvName + ":" + streamName
try:
streamTypePv = Pv(streamPvName + ":StreamType")
streamTypePv.connect(0.5)
streamTypePv.get(timeout=1.0)
except Exception, msg:
if verbose:
print "Stream %s not found." % streamName
return
def caPutValue(pvName, value, verbose=True):
try:
# See if this PV exists
pv = Pv(pvName)
pv.connect(1.0)
pv.put(value, timeout=1.0)
except Exception, msg:
if verbose:
print "Unable to connect to PV:", pvName
if showCAErrors:
print >> sys.stderr, "failed: pyca exception: ", msg
return
def printPvNameValue(pvName):
try:
pv = Pv(pvName)
pv.connect(0.1)
pv.get()
if isinstance(pv.value, str):
print "%s \"%-.30s\"" % (pv.name, pv.value)
else:
print "%s %-.30s" % (pv.name, pv.value)
except pyca.pyexc, msg:
if showCAErrors:
print >> sys.stderr, "failed: pyca exception: ", msg
pass
def caGetValue(pvName, verbose=True, timeout=0.1):
try:
# See if this PV exists
pv = Pv(pvName)
pv.connect(timeout)
pv.get()
return pv.value
except Exception, msg:
if verbose:
print "Unable to connect to PV: %s" % pvName
if showCAErrors:
print >> sys.stderr, "failed: pyca exception: ", msg
return None
def put(self, value):
""" put value to the Pv, returns the value itself """
if (is_debug_on()):
logprint("caput %s in %s\n" % (value, self.name))
pycaPv.put(self, value, time_out_get)
return value
def __init__(self, pv_x, pv_alpha, pv_z):
self.pv_obj_x = Pv(pv_x)
self.pv_obj_xp = Pv(pv_xp)
self.pv_obj_z = Pv(pv_z)
def get_centroid(self):
"""Return the centroid of the image."""
self.centroid, self.bounding_box = self.detector.find(Pv.get())
return self.centroid
class Magnet(object):
kick_delta = 0.0002 #in kG
def __init__(self, device_name, z_pos):
self.device_name = device_name
self.z = z_pos
self.bctrl_pv = Pv("{}:BCTRL".format(device_name))
self.bact_pv = Pv("{}:BACT".format(device_name))
@classmethod
def pv_count(cls):
return 2
@property
def name(self):
return self.device_name
def connect(self):
self.bctrl_pv.connect()
self.bact_pv.connect()
def connected(self):
if self.bctrl_pv.state() == 2 and self.bact_pv.state() == 2:
return True
else:
return False
def monitor(self):
self.bctrl_pv.monitor(pyca.DBE_VALUE)
self.bact_pv.monitor(pyca.DBE_VALUE)
@property
def kick_setpoint(self):
return self.bctrl_pv.data["value"]
@kick_setpoint.setter
def kick_setpoint(self, new_setpoint):
return self.bctrl_pv.put(new_setpoint)
@property
def kick_readback(self):
return self.bact_pv.data["value"]
def increase_kick(self):
before_val = self.kick_setpoint
new_val = before_val + (self.kick_delta)
self.kick_setpoint = new_val
def decrease_kick(self):
before_val = self.kick_setpoint
new_val = before_val - (self.kick_delta)
self.kick_setpoint = new_val
def __init__(self, device_name, z_pos):
self.device_name = device_name
self.z = z_pos
self.bctrl_pv = Pv("{}:BCTRL".format(device_name))
self.bact_pv = Pv("{}:BACT".format(device_name))
def caput(PVName, val): """Same definition of caput but with a connect timeout of 10.0""" pv = Pv(PVName) pv.connect(timeout=10.0) pv.put(value=val, timeout=10.0) pv.disconnect()
