741 lines
22 KiB
Python
Executable File
741 lines
22 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# *-----------------------------------------------------------------------*
|
|
# | |
|
|
# | Copyright (c) 2024 by Paul Scherrer Institute (http://www.psi.ch) |
|
|
# | |
|
|
# | Author Thierry Zamofing (thierry.zamofing@psi.ch) |
|
|
# *-----------------------------------------------------------------------*
|
|
|
|
"""
|
|
Furka ARES chamber visualization
|
|
|
|
For simulated motor IOC:
|
|
/home/zamofing_t/Documents/prj/SwissFEL/test_ioc/MotorSim/iocBoot/ARESvis/ARESvis.cmd
|
|
For motor ui:
|
|
caQtDM ~/Documents/prj/SwissFEL/test_ioc/MotorSim/iocBoot/ARESvis/ARESvis.ui&
|
|
|
|
|
|
self.pv_angles = [epics.PV("SATES30-ARES:MOT_SRY.RBV"), epics.PV("SATES30-ARES:MOT_DRY.RBV"), epics.PV("SATES30-ARES:MOT_2TRY.RBV")]
|
|
|
|
SATES30-RIXS:MOT_RY.RBV # sliding seal
|
|
SATES30-ARES:MOT_JFRY.RBV # jungfrau detector angle:
|
|
SATES30-ARES:MOT_2TRY.RBV # 2thetha angle: foc.mirror Diode2 Diode3
|
|
SATES30-ARES:MOT_DRY.RBV # detector angle: Diode1 Mirror
|
|
SATES30-ARES:MOT_SRY.RBV # sample rotation
|
|
|
|
|
|
bitmask for simulation:
|
|
0x01: EPICS motors
|
|
0x02:
|
|
0x04:
|
|
0x08:
|
|
0x10:
|
|
0x20:
|
|
0x40:
|
|
0x80:
|
|
|
|
"""
|
|
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QSlider, QLineEdit,\
|
|
QCheckBox, QHBoxLayout, QVBoxLayout, QGroupBox, QGridLayout, QComboBox
|
|
from PyQt5.QtGui import QPainter, QColor, QPen, QBrush, QPolygon, QPolygonF, QTransform, QPainterPath
|
|
from PyQt5.QtCore import QPoint, QPointF, Qt,pyqtSignal
|
|
|
|
import PyQt5.QtGui as QtGui
|
|
import PyQt5.QtCore as QtCore
|
|
import PyQt5.QtWidgets as QtW
|
|
from PyQt5.uic import loadUiType
|
|
import numpy as np
|
|
|
|
import sys, logging, copy
|
|
import epics
|
|
|
|
if sys.version_info[0] < 3 or sys.version_info[1] < 6:
|
|
print(f"Must be using Python 3.6 or newer. Try e.g. /opt/gfa/python-3.8/latest/bin/python /sf/furka/bin/ARESvis")
|
|
|
|
_log=logging.getLogger(__name__)
|
|
|
|
import logging
|
|
|
|
class col:
|
|
d = '\033[0m' #default
|
|
r = '\033[31m' #red
|
|
g = '\033[32m' #green
|
|
y = '\033[33m' #yellow
|
|
rr= '\033[91m' #red(bright)
|
|
gg= '\033[92m' #green(bright)
|
|
yy= '\033[93m' #yellow(bright)
|
|
b = '\033[1m' #bold
|
|
u = '\033[4m' #underline
|
|
R = '\033[1;31m' #bold, red
|
|
G = '\033[1;32m' #bold, green
|
|
Y = '\033[1;33m' #bold, yellow
|
|
|
|
|
|
class logHandler(logging.StreamHandler):
|
|
def __init__(self):
|
|
logging.StreamHandler.__init__(self)
|
|
|
|
def emit(self, record):
|
|
'''override function of base class'''
|
|
try:
|
|
msg=self.format(record)
|
|
# print(record.__dict__)
|
|
if record.levelno<=10:
|
|
c=col.g
|
|
elif record.levelno<=20:
|
|
c=col.y
|
|
elif record.levelno<=30:
|
|
c=col.yy
|
|
elif record.levelno<=40:
|
|
c=col.r
|
|
else:
|
|
c=col.rr+col.b
|
|
msg=c+msg+col.d
|
|
stream=self.stream
|
|
stream.write(msg+self.terminator)
|
|
self.flush()
|
|
except RecursionError:
|
|
raise
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
|
|
class ARESdevice():
|
|
_lutDifrBeamPaint=( # (number of difr beam,draw mode,alpha,width)
|
|
(4, 2, 190, 0),
|
|
(4, 1, 200, 0),
|
|
(32, 1, 120, 0),
|
|
(8, 1, 196, 0),
|
|
(32, 0, 120, 3),
|
|
(32, 2, 255, 0),
|
|
)
|
|
|
|
def __init__(self,name,**kwargs):
|
|
self._name=name
|
|
self._paint=p={
|
|
'ofs':(820, 350), # location of device
|
|
'rArm':int(540), # 540mm inner radius of chamber (RIXS arm)
|
|
'r2Th':int(375), # 375mm radius 2Theta platfform
|
|
'rJFr':int(270), # 270mm radius of Jungfrau
|
|
'rDet':int(207.5), # 207.5mm radius of detector table
|
|
'rTrg':int(168.5), # 168.5mm radius of target
|
|
'szArm':(20, 50),
|
|
'aArm':100, # angle RIXS arm
|
|
'aJFr':140, # angle detector
|
|
'a2Th':30, # angle 2thetha
|
|
'aDet':-20, # angle detector
|
|
'aTrg':10, # angle target
|
|
|
|
'mode':4, #difraction beam paint mode
|
|
'szG':(200, 5), # size VLS grating
|
|
'szD':(150, 5), # size detector
|
|
'sclTrf':(2**(6/2), 2**(-2/2)), # scaling transfformation [angle, distance]
|
|
}
|
|
# 2thetha angle SATES30-ARES:MOT_2TRY
|
|
# detector angle SATES30-ARES:MOT_DRY
|
|
# sliding seal SATES30-RIXS:MOT_RY
|
|
|
|
p.update(kwargs)
|
|
self._geo=g={
|
|
'r1':2000, # distance probe grating
|
|
'r2':3500, # distance grating detector
|
|
'aa':88, # grating angle
|
|
'bb':87, # reflection angle
|
|
'cc':22, # detector angle
|
|
}
|
|
self.setGeometry(g)
|
|
|
|
|
|
def setGeometry(self,geo):
|
|
self._geo=geo
|
|
p=self._paint
|
|
sclA,sclD=p['sclTrf']
|
|
p.update({
|
|
'r1':int(geo['r1']*sclD),
|
|
'r2':int(geo['r2']*sclD),
|
|
'aa':int((90-geo['aa'])*sclA),
|
|
'bb':int((90-geo['bb'])*sclA),
|
|
'cc':int(geo['cc']),
|
|
})
|
|
|
|
def geometry2motor(self):
|
|
# returns raw motor positions
|
|
# offset detector plane to deflected beam: 34deg
|
|
|
|
geo=self._geo
|
|
r1,r2,aa,bb,cc=geo['r1'],geo['r2'],geo['aa'],geo['bb'],geo['cc']
|
|
mt=gtz=gty1=gty2=grx=gtx=dtz=dty1=dty2=drx=None
|
|
degArm=90-aa+90-bb
|
|
radArm=np.deg2rad(degArm)
|
|
gtz=r1
|
|
grx=90-aa
|
|
dtz=np.cos(radArm)*r2
|
|
dty1=dty2=np.sin(radArm)*r2
|
|
drx=90-aa+90-bb+cc-34
|
|
dd=cc-34 # angle of bellow to detector
|
|
|
|
geo.update({
|
|
'mt':mt,
|
|
'gtz':gtz,
|
|
'gty1':gty1,
|
|
'gty2': gty2,
|
|
'grx':grx,
|
|
'gtx':gtx,
|
|
'dtz':dtz,
|
|
'dty1':dty1,
|
|
'dty2':dty2,
|
|
'drx':drx})
|
|
|
|
if degArm>10:
|
|
raise(ValueError('angle arm > 10deg'))
|
|
elif degArm<1:
|
|
raise(ValueError('angle arm < 1deg'))
|
|
elif abs(dd)>15:
|
|
raise(ValueError('angle bellow to detector > 15deg'))
|
|
|
|
def containsPoint(self,point):
|
|
try:
|
|
pg=self._polygon
|
|
except AttributeError:
|
|
return False
|
|
return pg.containsPoint(point,Qt.OddEvenFill)
|
|
|
|
@staticmethod
|
|
def plotOrig(qp):
|
|
penR=QPen(QtCore.Qt.red, 2, QtCore.Qt.SolidLine)
|
|
penG=QPen(QtCore.Qt.green, 2, QtCore.Qt.SolidLine)
|
|
pOrig=qp.pen()
|
|
qp.setPen(penR)
|
|
qp.drawLine(-20, 0, 20, 0)
|
|
qp.drawLine( 20, 0, 16, 2)
|
|
qp.setPen(penG)
|
|
qp.drawLine(0, -20, 0, 20)
|
|
qp.drawLine(0, 20, 2, 16)
|
|
qp.setPen(pOrig)
|
|
|
|
def paint(self,qp):
|
|
# qp QPainter to paint on
|
|
# ofs caanter to draw
|
|
# scl scaling for x and y translation of coordinate systems
|
|
# paintMode: mode how to paint the diffraction beam
|
|
p=self._paint
|
|
ofs=p['ofs']
|
|
|
|
rArm=p['rArm']
|
|
r2Th=p['r2Th']
|
|
rJFr=p['rJFr']
|
|
rDet=p['rDet']
|
|
rTrg=p['rTrg']
|
|
|
|
aArm=p['aArm']
|
|
a2Th=p['a2Th']
|
|
aJFr=p['aJFr']
|
|
aDet=p['aDet']
|
|
aTrg=p['aTrg']
|
|
sclTrf=p['sclTrf']
|
|
|
|
tickW,tickL=3,20 # tick px-width, tick len
|
|
diW,diH=40,20 # diodes
|
|
miW,miH=50,10 # mirrors
|
|
tgW,tgH=80,30 # target
|
|
|
|
# --- prepare transformations ---
|
|
# tf0: target not rotated
|
|
# tfArm: target center rotated angle aaArm
|
|
# tf2Th: target center rotated angle tf2Th
|
|
# tfDet: target center rotated angle aaDet
|
|
# tfTrg: target center rotated angle aaTrg
|
|
|
|
tf0=QTransform()
|
|
tf0.translate(ofs[0], ofs[1])
|
|
tf0.scale(sclTrf[1],sclTrf[1])
|
|
tfArm=copy.copy(tf0) # center
|
|
tfArm.rotate(-aArm)
|
|
tfJFr=copy.copy(tf0)
|
|
tfJFr.rotate(-aJFr)
|
|
tf2Th=copy.copy(tf0)
|
|
tf2Th.rotate(-a2Th)
|
|
tfDet=copy.copy(tf0)
|
|
tfDet.rotate(-aDet)
|
|
tfTrg=copy.copy(tf0)
|
|
tfTrg.rotate(-aTrg)
|
|
#tfd.translate(r2,0).rotate(-cc)
|
|
|
|
penBk=QPen(QtCore.Qt.black, 0, QtCore.Qt.SolidLine)
|
|
penWt=QPen(QtCore.Qt.white, 1, QtCore.Qt.SolidLine)
|
|
penYl=QPen(QtCore.Qt.yellow, 1, QtCore.Qt.SolidLine)
|
|
penBl=QPen(QtCore.Qt.blue, 1, QtCore.Qt.SolidLine)
|
|
penRd=QPen(QtCore.Qt.red, 1, QtCore.Qt.SolidLine)
|
|
|
|
# --- visualize ---
|
|
#qp.setRenderHints(QPainter.HighQualityAntialiasing)
|
|
|
|
# setup and plot dragable region
|
|
self._polygon=QPolygon([
|
|
QPoint(*tf0.map(-rArm ,-rArm)),
|
|
QPoint(*tf0.map(-rArm ,+rArm+100)),
|
|
QPoint(*tf0.map(+rArm,+rArm+100)),
|
|
QPoint(*tf0.map(+rArm,-rArm)),])
|
|
qp.setBrush(QColor(0, 0, 0,64))
|
|
qp.drawPolygon(self._polygon)
|
|
|
|
# plot beam path
|
|
|
|
qp.setTransform(tf0)
|
|
qp.setPen(penBk)
|
|
qp.setBrush(QColor(128, 128, 128, 128)) #r,g,b,a
|
|
|
|
#circles of rotation
|
|
#qp.drawEllipse(-rArm, -rArm, 2*rArm, 2*rArm) # ARES chamber
|
|
#qp.drawEllipse(-r2Th, -r2Th, 2*r2Th, 2*r2Th) # 2theta
|
|
#qp.drawEllipse(-rJFr, -rJFr, 2*rJFr, 2*rJFr) # jungfrau
|
|
#qp.drawEllipse(-rDet, -rDet, 2*rDet, 2*rDet) # detector
|
|
#qp.drawEllipse(-rTrg, -rTrg, 2*rTrg, 2*rTrg) # target
|
|
|
|
for r1,r2,col in (
|
|
(rArm,r2Th,QColor(255, 0, 0, 32)), #2theta
|
|
(r2Th,rDet,QColor( 0,255, 0, 32)), #Jungfrau
|
|
#(r2Th,rJFr,QColor( 0,255, 0, 32)), #Jungfrau
|
|
#(rJFr,rDet,QColor(255, 0,255, 32)), #detector
|
|
(rDet,rTrg,QColor( 0, 0,255, 32)), #target
|
|
):
|
|
path=QPainterPath()
|
|
qp.setBrush(col) #r,g,b,a
|
|
path.addEllipse(-r1, -r1, 2*r1, 2*r1)
|
|
path.addEllipse(-r2, -r2, 2*r2, 2*r2) # Jungfrau
|
|
qp.drawPath(path)
|
|
qp.setBrush(Qt.NoBrush)
|
|
qp.drawEllipse(-rJFr, -rJFr, 2*rJFr, 2*rJFr) # jungfrau
|
|
qp.setBrush(QColor(0,255,255,32)) # r,g,b,a
|
|
qp.drawEllipse(-rTrg, -rTrg, 2*rTrg, 2*rTrg) # target
|
|
|
|
|
|
#beam arrow
|
|
qp.setPen(QPen(QtCore.Qt.black, 3, QtCore.Qt.SolidLine))
|
|
qp.drawLine(0,+rArm+100,0,rArm)
|
|
qp.drawPolygon(QPolygon([QPoint(0,rArm),QPoint(-5,rArm+20),QPoint(+5,rArm+20),]))
|
|
|
|
#crosshair
|
|
qp.setPen(penBk)
|
|
qp.drawLine(0,-rArm,0,rArm)
|
|
qp.drawLine(-rArm,0,rArm,0)
|
|
|
|
#self.plotOrig(qp)
|
|
#qp.setPen(penRd)
|
|
#qp.drawRect(-10, -10+rArm, 20, 20)
|
|
|
|
#--- RIXS-arm devices ---
|
|
qp.setTransform(tfArm)
|
|
qp.setPen(QPen(QtCore.Qt.red, tickW, QtCore.Qt.SolidLine))
|
|
qp.drawLine(0,-rArm,0,-rArm+tickL) #tick
|
|
qp.setPen(penBk)
|
|
qp.setBrush(QColor(255,0,0,128))
|
|
qp.drawRect(-60, -150-rArm, 120, 150) # 2th mount sample
|
|
qp.drawRect(-300, -600-rArm, 600, 450) # 2th mount sample
|
|
|
|
#--- 2-theta devices ---
|
|
qp.setTransform(tf2Th)
|
|
qp.setPen(QPen(QtCore.Qt.green, tickW, QtCore.Qt.SolidLine))
|
|
qp.drawLine(0,-r2Th,0,-r2Th+tickL) #tick
|
|
qp.setPen(penBk)
|
|
qp.setBrush(QColor(0,255,0,192))
|
|
|
|
#mirror:310x30mm, 10-40mm dist, 40mm outside 2th
|
|
qp.translate(20,-r2Th-40);qp.rotate(2)
|
|
qp.drawRect(0, 0, 30, 310) # foc. mirror 1
|
|
qp.setTransform(tf2Th);qp.translate(-20,-r2Th-40);qp.rotate(-2)
|
|
qp.drawRect(-30, 0, 30, 310) # foc. mirror 2
|
|
|
|
qp.setTransform(tf2Th);qp.rotate(20);qp.translate(-diW/2,-r2Th);
|
|
qp.drawRect(0, 0, diW, diH) # diode2
|
|
qp.setTransform(tf2Th);qp.rotate(50);qp.translate(-diW/2,-r2Th);
|
|
qp.drawRect(0, 0, diW, diH) # diode3
|
|
|
|
#--- Jungfrau devices ---
|
|
qp.setTransform(tfJFr)
|
|
qp.setPen(QPen(QtCore.Qt.magenta, tickW, QtCore.Qt.SolidLine))
|
|
qp.drawLine(0,-rJFr,0,-rJFr+tickL) #tick
|
|
qp.setPen(penBk)
|
|
qp.setBrush(QColor(255,0,255,192))
|
|
jfW,jfH=80,20 # jungfrau detector
|
|
qp.setTransform(tfJFr);qp.translate(-jfW/2,-rJFr);
|
|
qp.drawRect(0, -jfH, jfW, jfH) # detector mount sample
|
|
|
|
#--- detector devices ---
|
|
qp.setTransform(tfDet)
|
|
qp.setPen(QPen(QtCore.Qt.blue, tickW, QtCore.Qt.SolidLine))
|
|
qp.drawLine(0,-rDet,0,-rDet+tickL) #tick
|
|
qp.setPen(penBk)
|
|
qp.setBrush(QColor(0,0,255,192))
|
|
qp.setTransform(tfDet);qp.rotate(10);qp.translate(-diW/2,-rDet);
|
|
qp.drawRect(0, 0, diW, diH) # diode1
|
|
qp.setTransform(tfDet);qp.rotate(40);qp.translate(0,-rDet+miW/2);qp.rotate(-45)
|
|
qp.drawRect(-int(miW/2), 0, miW, miH) # mirror1
|
|
|
|
|
|
#--- target devices ---
|
|
qp.setTransform(tfTrg)
|
|
qp.setPen(QPen(QtCore.Qt.cyan, tickW, QtCore.Qt.SolidLine))
|
|
qp.drawLine(0,-rTrg,0,-rTrg+tickL) #tick
|
|
qp.setPen(penBk)
|
|
qp.setBrush(QColor(0,255,255,192))
|
|
qp.drawRect(int(-(tgW/2)), -tgH, tgW, tgH) # target mount sample
|
|
|
|
# --- fixed objects ---
|
|
#parabola mirror
|
|
qp.setTransform(tf0)
|
|
qp.setPen(penBk)
|
|
qp.setBrush(QColor(80,80,80,128))
|
|
a,b=50.8,12
|
|
path=QPainterPath()
|
|
path.moveTo(-b-a/2,a)
|
|
path.lineTo(-b-a/2,2*a)
|
|
path.lineTo( a/2,2*a)
|
|
path.lineTo( a/2,2*a)
|
|
path.cubicTo(a/2-20,2*a, -a/2,a+20, -a/2,a)
|
|
path.lineTo(-b-a/2,a)
|
|
qp.drawPath(path)
|
|
#qp.drawPolygon(QPolygonF([QPointF(-b-a/2,a),
|
|
# QPointF(-b-a/2,2*a),
|
|
# QPointF( a/2,2*a),
|
|
# QPointF( -a/2,a),]))
|
|
qp.setPen(penBl)
|
|
qp.drawLine(0 ,0 ,int(a/2) ,int(2*a))
|
|
qp.drawLine(int(rArm),int(2*a),int(a/2) ,int(2*a))
|
|
qp.drawLine(0 ,0 ,int(-a/2),int(a ))
|
|
qp.drawLine(int(rArm),int(a) ,int(-a/2),int(a ))
|
|
|
|
|
|
|
|
#qp.setPen(penBk)
|
|
#qp.drawRect(-10, -10+rArm, 20, 20)
|
|
#self.plotOrig(qp)
|
|
#qp.setTransform(tf2Th)
|
|
#qp.setPen(penYl)
|
|
#qp.drawRect(-10, -10+r2Th, 20, 20)
|
|
#self.plotOrig(qp)
|
|
#qp.setTransform(tfDet)
|
|
#qp.setPen(penBl)
|
|
#qp.drawRect(-10, -10+r2Th+20, 20, 20)
|
|
#qp.setTransform(tfTrg)
|
|
#qp.setPen(penBl)
|
|
#qp.drawRect(-10, -10+r2Th+20, 20, 20)
|
|
#self.plotOrig(qp)
|
|
#qp.setCompositionMode(QtGui.QPainter.CompositionMode_Lighten)
|
|
#qp.setCompositionMode(QtGui.QPainter.CompositionMode_SourceOver)
|
|
#mouse move polygon
|
|
#qp.setTransform(QTransform())
|
|
#qp.setPen(penRd)
|
|
#qp.drawPolygon(self._polygon)
|
|
#origin crosses
|
|
#for tf in (tf0,tfa,tfab,tfc):#,tfg,tfs):#,tfc,tfs):
|
|
# qp.setTransform(tf);self.plotOrig(qp)
|
|
|
|
class WndVisualize(QWidget):
|
|
_pv2key={
|
|
'SATES30-RIXS:MOT_RY.RBV' :'aArm',
|
|
'SATES30-ARES:MOT_2TRY.RBV':'a2Th',
|
|
'SATES30-ARES:MOT_JFRY.RBV':'aJFr',
|
|
'SATES30-ARES:MOT_DRY.RBV' :'aDet',
|
|
'SATES30-ARES:MOT_SRY.RBV' :'aTrg'
|
|
}
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.initUI()
|
|
self.connectEPICS()
|
|
|
|
def initUI(self):
|
|
self.setGeometry(560, 100, 1300, 800)
|
|
self.setWindowTitle('Visualize')
|
|
app=QApplication.instance()
|
|
dev=app._dev
|
|
self._wdGrpDraw=w=QGroupBox(dev._name,self)
|
|
w.move(10,10)
|
|
row=0
|
|
lg=QGridLayout(w)
|
|
pDev=dev._paint
|
|
for key, rng, tk in (
|
|
('aArm',(0,360,), 30), # angle ARES sliding seal
|
|
('a2Th',(0,360,), 30), # angle 2thetha
|
|
('aJFr' ,(0,360,), 30), # angle Jungfrau
|
|
('aDet',(0,360,), 30), # angle detector
|
|
('aTrg',(0,360,), 30), # angle target
|
|
('sclA', ( -8, 8), 1),
|
|
('sclD', (-8, 8), 1),):
|
|
|
|
wLb=QLabel(f"<font>{key}</font>",objectName=key) #MOST BE with <font> as it is changed later and else creates a seg fault
|
|
|
|
wSl=QSlider(QtCore.Qt.Horizontal,objectName=key)
|
|
wSl.setFixedWidth(200);wSl.setMinimum(rng[0]);wSl.setMaximum(rng[1])
|
|
if key.startswith('scl'):
|
|
if key[-1]=='A':
|
|
v=pDev['sclTrf'][0]
|
|
else:
|
|
v=pDev['sclTrf'][1]
|
|
v=int(round(np.log2(v)*2))
|
|
else:
|
|
v=pDev[key]
|
|
wSl.setValue(v)
|
|
wSl.setTickPosition(QSlider.TicksBelow);wSl.setTickInterval(tk)
|
|
wSl.valueChanged.connect(lambda val,key=key: self.sldChanged(key,val))
|
|
|
|
lg.addWidget(wLb, row, 0)
|
|
lg.addWidget(wSl, row, 1);row+=1
|
|
|
|
#self.event_update.connect(self.cb_update)
|
|
self.show()
|
|
|
|
def cb_update(self,*args,**kwargs):
|
|
_log.debug(f'{args} {kwargs}')
|
|
|
|
def connectEPICS(self):
|
|
_log.info('connect PVs')
|
|
self._pvDict=pvd=dict()
|
|
self._pvConnected=0
|
|
for pvn in self._pv2key.keys():
|
|
pv=epics.get_pv(pvn,connection_callback=self.OnConnectionChange,callback=self.OnValueChange)
|
|
pvd[pvn]=pv
|
|
_log.info(f'{pv}')
|
|
#epics.Motor checks the record type and will fail if the record is not online
|
|
#therefore use epics.Device
|
|
#epics.Device will force to connect the PV in Device.add_callback
|
|
#therefore use epics.PV.add_callback to acc callback
|
|
#as soon as the devices are online, they are connected
|
|
#but with epics.Device creating PV is not fully flexible. epics.get_pv proviles connection and value change callbacks that is way more flexible.
|
|
#therefore the lowest level of the library (only pvs is the best suited
|
|
#m=epics.Motor(rec_name)
|
|
#m=epics.Device(rec_name, delim='.',with_poll=False,attrs=('VAL', 'RBV', 'DESC', 'RVAL','LVIO', 'HLS', 'LLS'))
|
|
#m.add_callback('RBV', self.OnChangedRBV)
|
|
#pv=m.PV('RBV',connect=False)
|
|
#pv.add_callback(self.OnChangedRBV)
|
|
#pv.connection_callbacks
|
|
#if not pv.connected:
|
|
# disconnected.add(rec_name)
|
|
#print(pv.connected)
|
|
#devs.add(m)
|
|
|
|
def OnConnectionChange(self, pvname=None, conn=None, **kws):
|
|
pvc=self._pvConnected
|
|
if conn:
|
|
pvc+=1
|
|
else:
|
|
if pvc>0: pvc-=1
|
|
_log.info(f'PV connection {pvc}/{len(self._pvDict)}: {pvname} {conn}')
|
|
self._pvConnected=pvc
|
|
|
|
app=QApplication.instance()
|
|
wGrp=app._wndVisualize._wdGrpDraw
|
|
key=self._pv2key[pvname]
|
|
wLb=wGrp.findChild(QLabel, key)
|
|
if not conn:
|
|
v=f"<font color='#a00000'>{key}</font>"
|
|
wLb.setText(v)
|
|
else:
|
|
v=f"<font color='#00a000'>{key}</font>"
|
|
wLb.setText(v)
|
|
|
|
def OnValueChange(self, pvname, value, **kw):
|
|
#_log.info(kw) #{
|
|
# 'pvname': 'SATES30-ARES:MOT_2TRY.RBV', 'value': 102.507, 'char_value': '102.5070', 'status': 0, 'ftype': 20,
|
|
# 'chid': 26100744, 'host': 'localhost:5064', 'count': 1, 'access': 'read-only', 'write_access': False, 'read_access': True,
|
|
# 'severity': 0, 'timestamp': 1724915455.46745, 'posixseconds': 1724915455.0, 'nanoseconds': 467450100, 'precision': 4,
|
|
# 'units': 'deg', 'enum_strs': None, 'upper_disp_limit': 0.0, 'lower_disp_limit': 0.0, 'upper_alarm_limit': nan,
|
|
#'lower_alarm_limit': nan, 'lower_warning_limit': nan, 'upper_warning_limit': nan, 'upper_ctrl_limit': 0.0,
|
|
#'lower_ctrl_limit': 0.0, 'nelm': 1, 'type': 'time_double', 'typefull': 'time_double',
|
|
#'cb_info': (1, <PV 'SATES30-ARES:MOT_2TRY.RBV', count=1, type=time_double, access=read-only>)
|
|
#}
|
|
_log.info(f"PV val:{pvname}:{value}")
|
|
try:
|
|
key=self._pv2key[pvname]
|
|
except KeyError as e:
|
|
_log.warning(f"can't handle PV: {pvname}:{value}")
|
|
return
|
|
self.vis_update(key,value,'008000')
|
|
|
|
def vis_update(self,key,value,col='000000'):
|
|
app=QApplication.instance()
|
|
wGrp=app._wndVisualize._wdGrpDraw
|
|
wSl=wGrp.findChild(QSlider, key)
|
|
wSl.blockSignals(True)
|
|
wSl.setValue(int(value)) # move the slider without emiting a signal
|
|
wSl.blockSignals(False)
|
|
self.sldChanged(key,value) # emit the signal
|
|
#self.event_update.emit(pvname=pvname, value=None)
|
|
wLb=wGrp.findChild(QLabel, key)
|
|
v=f"<font color='#{col}'>{key}</font>"
|
|
wLb.setText(v)
|
|
|
|
def liveView(self):
|
|
# try to live update all PVs
|
|
_log.info('')
|
|
p2k=self._pv2key
|
|
for pv in self._pvDict.values():
|
|
pvn=pv.pvname
|
|
key=p2k[pvn]
|
|
if pv.connected:
|
|
value=pv.get()
|
|
self.vis_update(key,value,'008000')
|
|
print (pvn,key,value)
|
|
else:
|
|
print (pvn,key)
|
|
pass
|
|
|
|
|
|
def destroy(self, destroyWindow, destroySubWindows): #overloaded function
|
|
_log.info('destroy')
|
|
|
|
def closeEvent(self, event): #overloaded function
|
|
_log.info('closeEvent')
|
|
|
|
def sldChanged(self,key,val,*args,**kwargs):
|
|
app=QApplication.instance()
|
|
dev=app._dev
|
|
p=dev._paint
|
|
if key.startswith('scl'):
|
|
wGrp=self._wdGrpDraw
|
|
if key[-1]=='A':
|
|
p['sclTrf']=(2**(val/2),p['sclTrf'][1])
|
|
else:
|
|
p['sclTrf']=(p['sclTrf'][0],2**(val/2))
|
|
print(p['sclTrf'])
|
|
dev.setGeometry(dev._geo)
|
|
else:
|
|
p[key]=val
|
|
g=dev._geo
|
|
if key in ('r1','r2'):
|
|
sclD=p['sclTrf'][1]
|
|
g[key]=val/sclD
|
|
elif key in ('aa', 'bb'):
|
|
sclA=p['sclTrf'][0]
|
|
g[key]=90-val/sclA
|
|
else:
|
|
g[key]=val
|
|
wGrp=app._wndVisualize._wdGrpDraw
|
|
wLb=wGrp.findChild(QLabel, key)
|
|
v=f"<font color='#0000ff'>{key}</font>"
|
|
wLb.setText(v)#print(wLb,v)
|
|
|
|
self.update()
|
|
|
|
def mouseReleaseEvent(self, a0):
|
|
try:
|
|
del self._mouseDrag
|
|
except AttributeError:
|
|
pass
|
|
|
|
def mousePressEvent(self, a0):
|
|
app=QApplication.instance()
|
|
mousePos=a0.pos()
|
|
print(a0.type)
|
|
if a0.type()!=QtGui.QMouseEvent.MouseButtonPress:
|
|
return
|
|
wGrp=self._wdGrpDraw
|
|
#if wGrp.underMouse(): #draging sliders?
|
|
if wGrp.geometry().contains(mousePos):
|
|
self.liveView()
|
|
self._mouseDrag={'obj':wGrp, 'start':mousePos}
|
|
return
|
|
dev=app._dev
|
|
if dev.containsPoint(mousePos):
|
|
self._devSel=dev
|
|
wGrp=self._wdGrpDraw
|
|
wGrp.setTitle(dev._name)
|
|
devP=dev._paint
|
|
for wSl in wGrp.findChildren(QSlider):
|
|
#_log.info(wSl)
|
|
key=wSl.objectName()
|
|
if key.startswith('scl'):
|
|
if key[-1]=='A':
|
|
v=devP['sclTrf'][0]
|
|
else:
|
|
v=devP['sclTrf'][1]
|
|
v=int(round(np.log2(v)*2))
|
|
else:
|
|
v=devP[key]
|
|
wSl.setValue(int(v))
|
|
|
|
self._mouseDrag={'obj':dev,'start':(mousePos,dev._paint['ofs'])}
|
|
try:
|
|
_log.info(f'{self._mouseDrag}')
|
|
except AttributeError:
|
|
_log.info(f'no object to drag')
|
|
|
|
|
|
def mouseMoveEvent(self, a0):
|
|
try:
|
|
md=self._mouseDrag
|
|
except AttributeError:
|
|
return
|
|
obj=md['obj']
|
|
s=md['start']
|
|
if obj==self._wdGrpDraw:
|
|
p=a0.pos()
|
|
md['start']=p
|
|
p=obj.geometry().topLeft()+p-s
|
|
obj.move(p)
|
|
return
|
|
p=a0.pos()
|
|
ofs=QPoint(*s[1])+p-s[0]
|
|
_log.info(f'{p} {ofs}')
|
|
obj._paint['ofs']=(ofs.x(),ofs.y())
|
|
self.update()
|
|
|
|
def paintEvent(self, e):
|
|
qp = QPainter()
|
|
qp.begin(self)
|
|
qp.setRenderHints(QPainter.HighQualityAntialiasing)
|
|
app=QApplication.instance()
|
|
dev=app._dev
|
|
app._dev.paint(qp)
|
|
qp.end()
|
|
|
|
def updateDevice(self, dev):
|
|
self._devSel=dev
|
|
devP=dev._paint
|
|
wGrp=self._wdGrpDraw
|
|
wGrp.setTitle(dev._name)
|
|
for wSl in wGrp.findChildren(QSlider):
|
|
# _log.info(wSl)
|
|
key=wSl.objectName()
|
|
if key.startswith('scl'):
|
|
if key[-1]=='A':
|
|
v=devP['sclTrf'][0]
|
|
else:
|
|
v=devP['sclTrf'][1]
|
|
v=int(round(np.log2(v)*2))
|
|
else:
|
|
v=devP[key]
|
|
wSl.blockSignals(True)
|
|
wSl.setValue(v)
|
|
wSl.blockSignals(False)
|
|
self.update()
|
|
|
|
def OnEvent(self,*args,**kwargs):
|
|
#test event
|
|
print(f'OnEvent: {args} ,{kwargs}')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
import argparse
|
|
logging.basicConfig(level=logging.DEBUG, handlers=[logHandler()], format='%(levelname)s:%(module)s:%(lineno)d:%(funcName)s:%(message)s ')
|
|
|
|
|
|
def main():
|
|
epilog=__doc__ # +'\nExamples:'+''.join(map(lambda s:cmd+s, exampleCmd))+'\n'
|
|
parser=argparse.ArgumentParser(epilog=epilog, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
parser.add_argument('--mode', '-m', type=lambda x:int(x, 0), help='mode (see bitmasks) default=0x%(default)x', default=1)
|
|
parser.add_argument("--sim", "-s", type=lambda x: int(x,0), help="simulate devices (see bitmasks) default=0x%(default)x", default=0x01)
|
|
args=parser.parse_args()
|
|
_log.info('Arguments:{}'.format(args.__dict__))
|
|
|
|
app=QApplication(sys.argv)
|
|
app._args=args
|
|
app._dev=dev=ARESdevice('Furka-ARES')
|
|
|
|
if args.mode&0x01:
|
|
app._wndVisualize=wnd=WndVisualize()
|
|
wnd.show()
|
|
sys.exit(app.exec_())
|
|
|
|
main() |