def __init__(self,
parent,
partition,
module,
name,
dName=None,
isInt=False):
self.layout = QtGui.QHBoxLayout()
self.label = QtGui.QLabel(name)
self.layout.addWidget(self.label)
self.layout.addStretch()
# self.display = QtGui.QLabel("-")
self.display = PvDisplay()
self.display.connect_signal()
self.layout.addWidget(self.display)
parent.addLayout(self.layout)
if module is None:
pvbase = "DAQ:" + partition + ":"
else:
pvbase = "DAQ:" + partition + ":" + module + ":"
pvname = pvbase + name
print pvname
self.pv = Pv.Pv(pvname)
self.pv.monitor_start()
self.pv.add_monitor_callback(self.update)
if dName is not None:
dPvName = pvbase + dName
self.dPv = Pv.Pv(dPvName)
self.dPv.monitor_start()
self.dPv.add_monitor_callback(self.update)
else:
self.dPv = None
self.isInt = isInt
def __init__(self, pvname):
self.pvname = pvname
self.__pressure = Pv.Pv('%s:PMON' % pvname)
self.__state = Pv.Pv('%s:STATE' % pvname)
self.__state.set_string_enum(True)
self.__pres_status = Pv.Pv('%s:PSTATMON' % pvname)
self.__pres_status.set_string_enum(True)
def __init__(self, parent, pvbase, name, dName=None, isInt=False):
layout = QtGui.QHBoxLayout()
label = QtGui.QLabel(name)
label.setMinimumWidth(100)
# label.setMinimumWidth(300)
layout.addWidget(label)
#layout.addStretch()
self.__display = PvDisplay()
self.__display.connect_signal()
self.__display.setMinimumWidth(300)
layout.addWidget(self.__display)
parent.addLayout(layout)
pvname = pvbase+name
print pvname
self.pv = Pv.Pv(pvname)
self.pv.monitor_start()
self.pv.add_monitor_callback(self.update)
if dName is not None:
dPvName = pvbase+dName
self.dPv = Pv.Pv(dPvName)
self.dPv.monitor_start()
self.dPv.add_monitor_callback(self.update)
else:
self.dPv = None
self.isInt = isInt
def __init__(self, pvname='GDET:FEE1'):
self.pvname = pvname
self.__ch0 = Pv.Pv('%s:241:ENRC' % pvname)
self.__ch0_egu = Pv.Pv('%s:241:ENRC.EGU' % pvname)
self.__ch0_egu.set_string_enum(True)
self.__ch1 = Pv.Pv('%s:242:ENRC' % pvname)
self.__ch1_egu = Pv.Pv('%s:242:ENRC.EGU' % pvname)
self.__ch1_egu.set_string_enum(True)
def __init_states(self):
""" background thread to set up inpos, etc. once possible """
self.__preset_inp.wait_ready()
self.__preset, _, _ = self.__preset_inp.value.partition(" ")
self.__inpos = Pv.Pv('%s:IN_SET'%self.__preset)
self.__outpos = Pv.Pv('%s:OUT_SET'%self.__preset)
self.__indelta = Pv.Pv('%s:IN_DELTA'%self.__preset)
self.__outdelta = Pv.Pv('%s:OUT_DELTA'%self.__preset)
def __init__(self, name, pvname):
self.__name = name
self.__pvbase = pvname
self.__get_flow = Pv.Pv('%s:GetFlowSetpoint' % pvname,
initialize=False)
self.__egu = Pv.Pv('%s:GetFlowSetpoint.EGU' % pvname, initialize=False)
self.__set_flow = Pv.Pv('%s:SetFlowSetpoint' % pvname,
initialize=False)
self.__close = Pv.Pv('%s:CloseValve.PROC' % pvname, initialize=False)
self.__set_operating_mode = Pv.Pv('%s:SetOperatingMode' % pvname,
initialize=False)
def __init__(self, pv, name, pv_rbv=None, pv_sioc=None, waitTime=0.2, pv_to_mot=lambda x:x, mot_to_pv=lambda x:x, motorsobj=None, egu="mm"):
super(PvMotor, self).__init__(name, self._pv_move, self._pv_wm, self._pv_wait, motorsobj=motorsobj, egu=egu)
self.pvname = pv
self._pv = Pv.Pv(pv)
if pv_rbv is None:
self._pv_rbv = self._pv
else:
self._pv_rbv = Pv.Pv(pv_rbv)
self._pv_sioc = pv_sioc
self._waitTime = waitTime
self._pv_to_mot = pv_to_mot
self._mot_to_pv = mot_to_pv
def init_test_pvs(self):
self.pv_long = Pv.Pv("TEMP:UNITTEST:LONG", initialize=True)
self.pv_double = Pv.Pv("TEMP:UNITTEST:DOUBLE", initialize=True)
self.pv_string = Pv.Pv("TEMP:UNITTEST:STRING", initialize=True)
self.pv_enum = Pv.Pv("TEMP:UNITTEST:ENUM", initialize=True)
self.pv_enum.set_string_enum(True)
self.pv_waveform = Pv.Pv("TEMP:UNITTEST:WAVEFORM", initialize=True)
self.pv_long.wait_ready()
self.pv_double.wait_ready()
self.pv_string.wait_ready()
self.pv_enum.wait_ready()
self.pv_waveform.wait_ready()
def __init__(self,PVbase=None,edm=None):
if PVbase == None:
PVbase = 'LAS:FS%d' % laserDict[guessBeamline().lower()]["system"]
self._PVbase = PVbase
self._PVtarg = Pv.Pv(PVbase+':VIT:FS_TGT_TIME', initialize=True, monitor=True)
self._PVshifterStatus = Pv.Pv(PVbase+':MMS:PH:STATUS', initialize=True, monitor=True)
self._PVtarg.wait_ready(3.0)
self._PVshifterStatus.wait_ready(3.0)
self.ismoving=False
self._newtarget=None
self._lasttarget = self.getDelay()
self._lastmovetime = time()
self._edm_exec = edm
def __init__(self):
self.expname = expname[3:]
self.elog = pypsElog.pypsElog()
user_motors = [
["CXI:SC2:MMS:05","Sample_x"],
["CXI:SC2:MMS:06","Sample_y"],
["CXI:SC2:MMS:07","Sample_z"],
["CXI:USR:MXM:01","Sample_phi"],
# ["CXI:SC2:MMS:07","crystal_x"],
# ["CXI:SC2:MMS:08","crystal_y"],
]
# user_motors = [
# ["CXI:SC3:MMS:02","Sample_x"],
# ["CXI:SC3:MMS:03","Sample_y"],
# ["CXI:SC3:MMS:12","Sample_z"],
# ["CXI:SC3:MMS:11","Sample_phi"],
# ["CXI:SC3:MMS:07","rystal_x"],
# ["CXI:SC3:MMS:08","crystal_y"],
# ]
env.motors.add( *user_motors, group="user")
for item in user_motors:
alias = item[1]
setattr(self, alias, getattr(env.motors.all.m, alias))
self.gasdet_sig = Pv.Pv('GDET:FEE1:241:ENRC')
self.center = 125
self.pp = env.pp
self.event = env.event
#env.daq.add_readout_checks("Sc2Epix","Sc2Imp")
env.daq.add_readout_checks("Sc2Imp")
def __init__(self, pvname, label):
super(PvPushButton, self).__init__(label)
self.setMaximumWidth(25) # Revisit
self.clicked.connect(self.buttonClicked)
self.pv = Pv.Pv(pvname)
def __init__(self, basePV, iocPV, evrPV, desc='ipimb'):
self.basePV = basePV
self.__iocPV = iocPV
self.__evrPV = evrPV
self.__evrBase = evrPV.split(":CTRL")[0]
self.__delayPV = basePV + ':TrigDelay'
self.__gainPV = basePV + ':ChargeAmpRangeCH'
self.__biasPV = basePV + ':DiodeBias'
self.__minGain = 0
self.__maxGain = len(self._gain_enum_states)
self.__minDelay = 0
self.__maxDelay = 1e6
self.__minBias = 0
self.__maxBias = 100
self.__desc = desc
self.dconfpv = Pv.Pv(self.__evrPV)
self.dconfpv.config = False
self.delay = virtualmotor.VirtualMotor(self.desc() + '_delay',
self.__setDelay,
self.__getDelay,
self.__waitConfig)
self.gain = virtualmotor.VirtualMotor(self.desc() + '_gain',
self.setGain, self.getGain,
self.__waitConfig)
self.bias = virtualmotor.VirtualMotor(self.desc() + '_bias',
self.__setBias, self.__getBias,
self.__waitConfigBias)
def __init__(self):
## machine parameters
# self.sim_mode = False
self.__evpv = "SIOC:SYS0:ML00:AO627"
self.__BeTpv = "SATT:FEE1:320:RACT"
self.__BeMilspv = "SATT:FEE1:320:TACT"
self.__ebeamratepv = "EVNT:SYS0:1:LCLSBEAMRATE"
self.__isburstmodeenabled_pv = "IOC:BSY0:MP01:REQBYKIKBRST"
self.__isburstpcmodeenabled_pv = "IOC:BSY0:MP01:REQPCBRST"
self.__burstDelivered_pv = Pv.Pv("PATT:SYS0:1:MPSBURSTCTRL")
self.__freqs = {}
self.__freqs["Full"] = 0
self.__freqs["full"] = 0
self.__freqs["30Hz"] = 1
self.__freqs["10Hz"] = 2
self.__freqs["5Hz"] = 3
self.__freqs["1Hz"] = 4
self.__freqs["0.5Hz"] = 5
self.__dictRateToEnum = {
0.5: 5,
1: 4,
5: 3,
10: 2,
30: 1,
120: 0,
0: 0
}
def __create_pv(self,
name,
is_str=False,
monitor=False,
is_plugin_pv=True):
if is_plugin_pv:
pv = Pv.Pv('%s:%s:%s' % (self.pvname, self.__plugin, name),
initialize=True,
monitor=monitor)
else:
pv = Pv.Pv('%s:%s' % (self.pvname, name),
initialize=True,
monitor=monitor)
if is_str:
pv.set_string_enum(True)
return pv
def __init__(self, pv, label):
super(PvTxt, self).__init__(label)
self.connect_signal()
self.pv = Pv.Pv(pv)
self.pv.monitor_start()
print 'Monitor started ' + pv
self.pv.add_monitor_callback(self.update)
def __init__(self, pvname, choices):
super(PvEditCmb, self).__init__(choices)
self.connect_signal()
self.currentIndexChanged.connect(self.setValue)
self.pv = Pv.Pv(pvname)
self.pv.monitor_start()
self.pv.add_monitor_callback(self.update)
def __init__(self, pv):
super(PvEditTxt, self).__init__()
self.connect_signal()
self.editingFinished.connect(self.setPv)
self.pv = Pv.Pv(pv)
self.pv.monitor_start()
self.pv.add_monitor_callback(self.update)
def __init__(self, pvname, label):
super(PvCheckBox, self).__init__(label)
self.connect_signal()
self.clicked.connect(self.pvClicked)
self.pv = Pv.Pv(pvname)
self.pv.monitor_start()
self.pv.add_monitor_callback(self.update)
def initPvMon(mon, pvname):
mon.pv = Pv.Pv(pvname)
print('Wait for ' + pvname + ' monitor_start')
mon.pv.monitor_start()
mon.pv.add_monitor_callback(mon.update)
# print('Wait for '+pvname+' get')
mon.pv.get()
mon.update(None)
def __init__(self):
"""Initialize experiment.
pacemaker_delay0: time_zero delay of pacemaker trigger [default=748917.9 ns]
inhibit_offset: inhibit trigger time before pacemaker trigger [default=500000 ns, i.e., 0.5 ms]
xray_delay0: x-ray arrival time zero.
"""
self.shutter_opo = Shutter('CXI:LAS:SHT:02:CMD')
self._laser_delay = Pv.Pv('LAS:FS5:VIT:FS_TGT_TIME_DIAL')
def setupUi(self, MainWindow, base, partn, shelf):
MainWindow.setObjectName(QtCore.QString.fromUtf8("MainWindow"))
self.centralWidget = QtGui.QWidget(MainWindow)
self.centralWidget.setObjectName("centralWidget")
pvbase = base + ':XPM:' + shelf + ':'
#ppvbase = pvbase+partn+':'
ppvbase = base + ':PART:' + partn + ':'
print 'pvbase : ' + pvbase
print 'ppvbase: ' + ppvbase
grid = QtGui.QGridLayout()
textWidgets = []
for i in range(32):
textWidgets.append(PvDblArrayW())
# Need to wait for pv.get()
time.sleep(2)
for i in range(14):
pv = Pv.Pv(pvbase + 'LinkLabel%d' % i)
grid.addWidget(QtGui.QLabel(pv.get()), i, 0)
grid.addWidget(textWidgets[i], i, 1)
for j in range(16, 21):
i = j - 16
pv = Pv.Pv(pvbase + 'LinkLabel%d' % j)
grid.addWidget(QtGui.QLabel(pv.get()), i, 2)
grid.addWidget(textWidgets[j], i, 3)
for j in range(28, 32):
i = j - 22
grid.addWidget(QtGui.QLabel('INH-%d' % (j - 28)), i, 2)
grid.addWidget(textWidgets[j], i, 3)
self.deadflnk = PvDblArray(ppvbase + 'DeadFLnk', textWidgets)
self.centralWidget.setLayout(grid)
self.centralWidget.resize(240, 340)
title = 'XPM:' + shelf + '\tPART:' + partn
MainWindow.setWindowTitle(title)
MainWindow.resize(240, 340)
MainWindow.setCentralWidget(self.centralWidget)
def __init__(self, pvbase):
super(DetBase, self).__init__()
prefix = pvbase + ':BASE:'
lo = QtWidgets.QVBoxLayout()
v = Pv.Pv(prefix + 'INTTRIGRANGE').get()
lo.addWidget(
QtWidgets.QLabel('Internal Trigger Range: %u - %u clks' %
(v[0], v[1])))
v = Pv.Pv(prefix + 'INTTRIGCLK').get()
lo.addWidget(
QtWidgets.QLabel('Internal Trigger Clock: %f MHz (%f ns)' %
(v, 1.e3 / v)))
v = Pv.Pv(prefix + 'INTTRIGVAL').get()
lo.addWidget(QtWidgets.QLabel('Internal Trigger Value: %u clks' % v))
if True:
hlo = QtWidgets.QHBoxLayout()
hlo.addWidget(QtWidgets.QLabel('Absolute Trigger Target (usecs)'))
hlo.addWidget(PvEditInt(prefix + 'ABSTRIGTARGET', ''))
hlo.addStretch(1)
lo.addLayout(hlo)
v = Pv.Pv(prefix + 'INTPIPEDEPTH').get()
lo.addWidget(QtWidgets.QLabel('Internal Pipeline Depth: %u' % v))
v = Pv.Pv(prefix + 'INTAFULLVAL').get()
lo.addWidget(QtWidgets.QLabel('Internal Almost Full Threshold: %u' %
v))
v = Pv.Pv(prefix + 'MINL0INTERVAL').get()
lo.addWidget(
QtWidgets.QLabel('Minimum Trigger Spacing (usecs): %f' % v))
v = Pv.Pv(prefix + 'UPSTREAMRTT').get()
lo.addWidget(
QtWidgets.QLabel('Upstream round trip time (usecs): %f' % v))
v = Pv.Pv(prefix + 'DNSTREAMRTT').get()
lo.addWidget(
QtWidgets.QLabel('Downstream round trip time (usecs)): %f' % v))
if True:
hlo = QtWidgets.QHBoxLayout()
hlo.addWidget(QtWidgets.QLabel('PARTITION'))
hlo.addWidget(PvEditInt(prefix + 'PARTITION', ''))
hlo.addStretch(1)
lo.addLayout(hlo)
lo.addStretch(1)
self.setLayout(lo)
def __init__(self, daq, motor, base_motor, hutch=None, aliases=None, channel=None, encoder_det=None, pvbase=None):
self._daq = daq
self.motor = motor
if not None in (hutch, aliases, channel):
self._encoder = usb_encoder.UsbEncoder(hutch, *aliases)
self.config = getattr(self._encoder, "ch{}".format(channel))
if encoder_det is not None:
self.encoder_det = encoder_det
if pvbase is not None:
self._pvset = Pv.Pv('%s:CH%d:ZEROCNT'%(pvbase,channel))
self._pvpos = Pv.Pv('%s:CH%d:POSITION'%(pvbase,channel))
self._pvoffset = Pv.Pv('%s:CH%d:OFFSET'%(pvbase,channel))
self._pvscale = Pv.Pv('%s:CH%d:SCALE'%(pvbase,channel))
self.set_zero = self._set_epics_zero
else:
self.set_zero = self._set_daq_zero
self.empty_scan = EmptyScan(motor, base_motor)
self._base_motor = base_motor
def _init_update_cb(self):
"""
Initialize event callback on update.
"""
self._update_pv = Pv.Pv(self.__pv_notify,
initialize=True,
monitor=True)
self._update_pv.add_monitor_callback(self._update_cb)
self._update_event = Event()
def __init__(self, pvname, label):
super(PvPushButton, self).__init__(label)
sz = len(label) * 8
if sz < 25:
sz = 25
self.setMaximumWidth(sz) # Revisit
self.clicked.connect(self.buttonClicked)
self.pv = Pv.Pv(pvname)
def __init__(self):
self._daq = env.daq
for pv,item in self._pvs.items():
print 'Adding ',pv, item
item['Pv'] = Pv.Pv(item['pv'])
self._daq = env.daq
self.hutch=expname[0:3]
self.aliases=['BEAM']
#Add monitor callback for AI
print 'adding analog input'
self.analog = Pv.Pv('CXI:SC2:AIO:01:RAW:ANALOGIN')
print 'add callback'
self.analog.add_monitor_callback(self.make_ready)
print 'add threading'
self.ready_for_row = threading.Event()
self.latch = False
self.event_timeout = 0.05 # timeout in seconds on event wait
def __init__(self):
self.howto()
#self.elog = pypsElog.pypsElog()
for pv, item in self._pvs.items():
print 'Adding ', pv, item
item['Pv'] = Pv.Pv(item['pv'])
setattr(self, pv, item['default'])
Pv.put(item['pv'] + '.DESC', item['desc'])
self.EXP = 'current'
self.run()
def test_units(self):
# Currently implemented based on .EGU field. Will change if we
# update pyca to give us the alarm severity directly.
egu = Pv.Pv("TEMP:UNITTEST:LONG.EGU", initialize=True)
egu.wait_ready()
egu.put("miles")
self.signal_wait(self.long_widget.units_updated_signal, timeout=2)
self.assertEqual(self.long_widget.units, "miles")
egu.put("mm")
self.signal_wait(self.long_widget.units_updated_signal, timeout=2)
self.assertEqual(self.long_widget.units, "mm")
def test_prec(self):
# Currently implemented based on .PREC field. Will change if we
# update pyca to give us the alarm severity directly.
prec = Pv.Pv("TEMP:UNITTEST:LONG.PREC", initialize=True)
prec.wait_ready()
prec.put(0)
self.signal_wait(self.long_widget.prec_updated_signal, timeout=2)
self.assertEqual(self.long_widget.prec, 0)
prec.put(4)
self.signal_wait(self.long_widget.prec_updated_signal, timeout=2)
self.assertEqual(self.long_widget.prec, 4)
def __load_pvs(self):
""" connect to all needed PVs for the attenuator and start monitoring if requested """
pv_dict = {}
for parname, (pvname, desc, opts) in ATT_PARAMS.iteritems():
monitor_opt = opts.get(MON_OPT, False)
enum_opt = opts.get(ENUM_OPT, False)
pv = Pv.Pv('%s:COM:%s'%(self.PVbase, pvname),monitor=monitor_opt)
if enum_opt:
pv.set_string_enum(True)
pv_dict[parname] = pv
return pv_dict
