def syncMoveRelative(self, position):
old_pos = self.positionValue
self.positionValue = old_pos + position
logging.info("TangoDCMotor: syncMoveRelative going to %s " %
str(self.convertValue(self.positionValue)))
self.positionChan.setValue(self.convertValue(self.positionValue))
dev = DeviceProxy(self.tangoname)
gevent.sleep(0.2) # allow MD2 to change the state
mystate = str(dev.State())
logging.info("TangoDCMotor: %s syncMoveRelative state is %s / %s " %
(self.tangoname, str(self.stateValue), mystate))
while mystate == "RUNNING" or mystate == "MOVING":
logging.info("TangoDCMotor: syncMoveRelative is moving %s" %
str(mystate))
gevent.sleep(0.1)
mystate = str(dev.State())
QApplication.processEvents(100)
class BLEnergy(Device):
stateEnergy = {
'ALARM': 'error',
'FAULT': 'error',
'RUNNING': 'moving',
'MOVING': 'moving',
'STANDBY': 'ready',
'UNKNOWN': 'unknown',
'DISABLE': 'disable',
'EXTRACT': 'outlimits'
}
def init(self):
self.moving = None
self.deviceOk = True
self.prev_state = None
self.doBacklashCompensation = False
# Channel and commands for monochormator pitch.
# it will be used here to make sure it is on before moving energy (PX2)
# not needed on PX1
self.mono_mt_rx_statech = None
self.mono_mt_rx_oncmd = None
# Connect to device BLEnergy defined "tangoname" in the xml file
try:
self.BLEnergydevice = DeviceProxy(self.getProperty("tangoname"))
except:
self.errorDeviceInstance(self.getProperty("tangoname"))
# Connect to device mono defined "tangoname2" in the xml file
# used for conversion in wavelength
try:
self.monodevice = DeviceProxy(self.getProperty("tangoname2"))
except:
self.errorDeviceInstance(self.getProperty("tangoname2"))
# Nom du device bivu (Energy to gap) : necessaire pour amelioration du positionnement de l'onduleur (Backlash)
try:
# self.U20Energydevice = DeviceProxy(self.getProperty("tangoname3"), movingState="RUNNING")
# Modif suite a changement par ICA de l etat du device U20 RUNNING devient MOVING
self.U20Energydevice = DeviceProxy(self.getProperty("tangoname3"))
except:
self.errorDeviceInstance(self.getProperty("tangoname3"))
self.doBacklashCompensation = self.getProperty("backlash")
# print self.doBacklashCompensation
try:
self.mono_mt_rx_statech = self.getChannelObject("mono_mt_rx_state")
self.mono_mt_rx_oncmd = self.getCommandObject("mono_mt_rx_on")
except KeyError:
logging.info(
"Beware that mt_rx control is not properly defined for BLEnergy"
)
try:
self.mono_mt_rx_fine_statech = self.getChannelObject(
"mono_mt_rx_fine_state")
self.mono_mt_rx_fine_oncmd = self.getCommandObject(
"mono_mt_rx_fine_on")
except KeyError:
logging.info(
"Beware that mt_rx control is not properly defined for BLEnergy"
)
self.get_energy_limits = self.getEnergyLimits
self.get_wavelength_limits = self.getWavelengthLimits
# parameters for polling
if self.deviceOk:
self.isConnected()
self.prev_state = str(self.BLEnergydevice.State())
energyChan = self.getChannelObject("energy")
energyChan.connectSignal("update", self.energyChanged)
stateChan = self.getChannelObject(
"state"
) # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.stateChanged)
self.can_move_energy = self.canMoveEnergy
self.move_energy = self.startMoveEnergy
self.move_wavelength = self.startMoveWavelength
def stateChanged(self, value):
if (str(value) == 'MOVING'):
self.moveEnergyCmdStarted()
if self.prev_state == 'MOVING' or self.moving == True:
if str(value) != 'MOVING':
self.moveEnergyCmdFinished()
self.prev_state = str(value)
self.emit('stateChanged', BLEnergy.stateEnergy[str(value)])
# function called during polling
def energyChanged(self, value):
#logging.getLogger("HWR").debug("%s: BLEnergy.energyChanged: %.3f", self.name(), value)
#logging.info(">>>>>>>> %s: BLEnergy.energyChanged: %.3f", self.name(), value)
wav = self.monodevice.read_attribute("lambda").value
if wav is not None:
self.emit('energyChanged', (value, wav))
def connectNotify(self, signal):
logging.getLogger("HWR").info("%s: BLEnergy.connectNotify, : %s",
self.name(), signal)
if signal == 'energyChanged':
self.energyChanged(self.BLEnergydevice.energy)
if signal == 'stateChanged':
self.stateChanged(str(self.BLEnergydevice.State()))
self.setIsReady(True)
# called by brick : not useful
def isSpecConnected(self):
logging.getLogger("HWR").debug("%s: BLEnergy.isSpecConnected",
self.name())
return True
def isConnected(self):
logging.getLogger("HWR").debug("%s: BLEnergy.isConnected", self.name())
return True
def sConnected(self):
logging.getLogger("HWR").debug("%s: BLEnergy.sConnected", self.name())
self.deviceOk = True
self.emit('connected', ())
def sDisconnected(self):
logging.getLogger("HWR").debug("%s: BLEnergy.sDisconnected",
self.name())
self.deviceOk = False
self.emit('disconnected', ())
def isDisconnected(self):
logging.getLogger("HWR").debug("%s: BLEnergy.isDisconnected",
self.name())
return True
# Definit si la beamline est a energie fixe ou variable
def canMoveEnergy(self):
logging.getLogger("HWR").debug("%s: BLEnergy.canMoveEnergy",
self.name())
return True
def getPosition(self):
return self.getCurrentEnergy()
def getCurrentEnergy(self):
if self.deviceOk:
return self.BLEnergydevice.energy
else:
return None
def getState(self):
return self.BLEnergydevice.State().name
def getEnergyComputedFromCurrentGap(self):
logging.getLogger("HWR").debug("%s: BLEnergy.getCurrentEnergy",
self.name())
if self.deviceOk:
# PL. Rq: if the device is not redy, it send a NaN...
return self.U20Energydevice.energy
else:
return None
def getCurrentUndulatorGap(self):
logging.getLogger("HWR").debug("%s: BLEnergy.getCurrentEnergy",
self.name())
if self.deviceOk:
return self.U20Energydevice.gap
else:
return None
def getCurrentWavelength(self):
logging.getLogger("HWR").debug("%s: BLEnergy.getCurrentWavelength",
self.name())
# Pb with the attribute name "lamdda" which is a keyword for python
if self.deviceOk:
# using calculation of the device mono
return self.monodevice.read_attribute("lambda").value
else:
return None
def getEnergyLimits(self):
logging.getLogger("HWR").debug("%s: BLEnergy.getEnergyLimits",
self.name())
if self.deviceOk:
# limits defined in tango
enconfig = self.BLEnergydevice.get_attribute_config("energy")
max = float(enconfig.max_value)
min = float(enconfig.min_value)
lims = (min, max)
logging.getLogger("HWR").info("HOS : energy Limits: %.4f %.4f" %
lims)
return lims
else:
return None
def getWavelengthLimits(self):
logging.getLogger("HWR").debug("%s: BLEnergy.getWavelengthLimits",
self.name())
if self.deviceOk:
lims = []
# Recuperation des limites en energie
energylims = self.getEnergyLimits()
# Conversion de la limite inferieure en wavelength superieure (Utilisation des fonctions de conversion du device mono)
self.monodevice.simEnergy = energylims[1]
lims.append(self.monodevice.simLambda)
# Conversion de la limite superieure en wavelength inferieure (Utilisation des fonctions de conversion du device mono)
self.monodevice.simEnergy = energylims[0]
lims.append(self.monodevice.simLambda)
# logging.getLogger("HWR").info("HOS : wavelength Limits: %.4f %.4f" % lims)
logging.getLogger("HWR").info("HOS : wavelength Limits: %s" % lims)
return lims
else:
return None
def startMoveEnergy(self, value, wait=False):
logging.getLogger("HWR").debug("%s: BLEnergy.startMoveEnergy: %.3f",
self.name(), float(value))
# MODIFICATION DE CETTE FONCTION POUR COMPENSER LE PROBLEME D'HYSTERESIS DE L"ONDULEUR
# PAR CETTE METHODE ON APPLIQUE TOUJOURS UN GAP CROISSANT
backlash = 0.1 # en mm
gaplimite = 5.5 # en mm
if self.mono_mt_rx_statech is not None and self.mono_mt_rx_oncmd is not None:
while str(self.mono_mt_rx_statech.getValue()) == 'OFF':
logging.getLogger("HWR").info(
"BLEnergy : turning mono1-mt_rx on")
self.mono_mt_rx_oncmd()
time.sleep(0.2)
if self.mono_mt_rx_fine_statech is not None and self.mono_mt_rx_fine_oncmd is not None:
while str(self.mono_mt_rx_fine_statech.getValue()) == 'OFF':
logging.getLogger("HWR").info(
"BLEnergy : turning mono1-mt_rx_fine on")
self.mono_mt_rx_fine_oncmd()
time.sleep(0.2)
if (str(self.BLEnergydevice.State()) != "MOVING" and self.deviceOk):
if self.doBacklashCompensation:
try:
# Recuperation de la valeur de gap correspondant a l'energie souhaitee
self.U20Energydevice.autoApplyComputedParameters = False
self.U20Energydevice.energy = value
newgap = self.U20Energydevice.computedGap
actualgap = self.U20Energydevice.gap
self.U20Energydevice.autoApplyComputedParameters = True
# On applique le backlash que si on doit descendre en gap
if newgap < actualgap + backlash:
# Envoi a un gap juste en dessous (backlash)
if newgap - backlash > gaplimite:
self.U20Energydevice.gap = newgap - backlash
else:
self.U20Energydevice.gap = gaplimite
self.U20Energydevice.gap = newgap + backlash
time.sleep(1)
except:
logging.getLogger("HWR").error(
"%s: Cannot move undulator U20 : State device = %s",
self.name(), str(self.U20Energydevice.State()))
try:
# Envoi a l'energie desiree
self.BLEnergydevice.energy = value
except:
logging.getLogger("HWR").error(
"%s: Cannot move BLEnergy : State device = %s",
self.name(), str(self.BLEnergydevice.State()))
else:
statusBLEnergydevice = self.BLEnergydevice.Status()
logging.getLogger("HWR").error(
"%s: Cannot move : State device = %s", self.name(),
str(self.BLEnergydevice.State()))
for i in statusBLEnergydevice.split("\n"):
logging.getLogger().error("\t%s\n" % i)
logging.getLogger().error("\tCheck devices")
def startMoveWavelength(self, value, wait=False):
logging.getLogger("HWR").debug(
"%s: BLEnergy.startMoveWavelength: %.3f", self.name(), value)
self.monodevice.simLambda = value
self.startMoveEnergy(self.monodevice.simEnergy)
# return self.startMoveEnergy(energy_val)
def cancelMoveEnergy(self):
logging.getLogger("HWR").debug("%s: BLEnergy.cancelMoveEnergy",
self.name())
self.BLEnergydevice.Stop()
self.moving = False
def energyLimitsChanged(self, limits):
logging.getLogger("HWR").debug(
"%s: BLEnergy.energyLimitsChanged: %.3f", self.name(), value)
self.monodevice.simEnergy = limits[0]
wav_limits.append[self.monodevice.simLambda]
self.monodevice.simEnergy = limits[1]
wav_limits.append[self.monodevice.simLambda]
self.emit('energyLimitsChanged', (limits, ))
if wav_limits[0] != None and wav_limits[1] != None:
self.emit('wavelengthLimitsChanged', (wav_limits, ))
else:
self.emit('wavelengthLimitsChanged', (None, ))
def moveEnergyCmdReady(self):
logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdReady",
self.name())
if not self.moving:
self.emit('moveEnergyReady', (True, ))
def moveEnergyCmdNotReady(self):
logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdNotReady",
self.name())
if not self.moving:
self.emit('moveEnergyReady', (False, ))
def moveEnergyCmdStarted(self):
logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdStarted",
self.name())
self.moving = True
#self.emit('moveEnergyStarted',(BLEnergy.stateEnergy[str(self.BLEnergydevice.State())]))
self.emit('moveEnergyStarted', ())
def moveEnergyCmdFailed(self):
logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdFailed",
self.name())
self.moving = False
self.emit('moveEnergyFailed', ())
def moveEnergyCmdAborted(self):
self.moving = False
logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdAborted",
self.name())
def moveEnergyCmdFinished(self):
logging.getLogger("HWR").debug("%s: BLEnergy.moveEnergyCmdFinished",
self.name())
self.moving = False
print 'moveEnergyFinished'
#self.emit('moveEnergyFinished',(BLEnergy.stateEnergy[str(self.BLEnergydevice.State())]))
self.emit('moveEnergyFinished', ())
def getPreviousResolution(self):
logging.getLogger("HWR").debug("%s: BLEnergy.getPreviousResolution",
self.name())
return (None, None)
def restoreResolution(self):
logging.getLogger("HWR").debug("%s: BLEnergy.restoreResolution",
self.name())
return (False, "Resolution motor not defined")
def errorDeviceInstance(self, device):
logging.getLogger("HWR").debug("%s: BLEnergy.errorDeviceInstance: %s",
self.name(), device)
db = DeviceProxy("sys/database/dbds1")
logging.getLogger().error("Check Instance of Device server %s" %
db.DbGetDeviceInfo(device)[1][3])
self.sDisconnected()
class TangoResolutionComplex(BaseHardwareObjects.Equipment):
# resoState = {
# None: 'unknown',
# 'UNKNOWN': 'unknown',
# 'CLOSE': 'closed',
# 'OPEN': 'opened',
# 'MOVING': 'moving',
# 'FAULT': 'fault',
# 'DISABLE': 'disabled',
# 'OFF': 'fault',
# 'ON': 'unknown'
# }
stateDict = {
"UNKNOWN": 0,
"OFF": 1,
"ALARM": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"2": 2,
"1": 1}
def _init(self):
self.currentResolution = None
self.currentDistance = None
self.currentWavelength = None
self.currentEnergy = None
self.connect("equipmentReady", self.equipmentReady)
self.connect("equipmentNotReady", self.equipmentNotReady)
#self.device = SimpleDevice(self.getProperty("tangoname"), waitMoves = False, verbose=False)
self.device = DeviceProxy(self.getProperty("tangoname"))
#self.device.timeout = 3000 # Setting timeout to 3 sec
#self.monodevice = SimpleDevice(self.getProperty("tangoname2"), waitMoves = False, verbose=False)
hobj = self.getProperty("BLEnergy")
logging.getLogger("HWR").debug('TangoResolution: load specify the %s hardware object' % hobj)
self.blenergyHO = None
if hobj is not None:
try:
self.blenergyHO=HardwareRepository.HardwareRepository().getHardwareObject(hobj)
except:
logging.getLogger("HWR").error('TangoResolutionComplex: BLEnergy is not defined in resolution equipment %s', str(self.name()))
if self.blenergyHO is not None:
#self.connect(self.blenergyHO, "energyChanged",self.energyChanged)
self.blenergyHO.connect("energyChanged",self.energyChanged)
else:
logging.info('TANGORESOLUTION : BLENERGY is not defined in TangoResolution equipment %s', str(self.name()))
#self.connect(self.blenergyHO,, "energyChanged",self.energyChanged)
#self.connect(self.beam_info_hwobj,
# "beamPosChanged",
# self.beam_position_changed)
#self.blenergyHO.connectSignal('energyChanged', self.energyChanged)
# creer un chanel sur l'energy: pour faire un update
positChan = self.getChannelObject("position") # utile seulement si statechan n'est pas defini dans le code
positChan.connectSignal("update", self.positionChanged)
stateChan = self.getChannelObject("state") # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.stateChanged)
self.currentDistance = self.device.position
self.currentEnergy = self.blenergyHO.getCurrentEnergy()
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
return BaseHardwareObjects.Equipment._init(self)
def init(self):
#self.detm = self.getDeviceByRole("detm")
#self.dtox = self.getDeviceByRole("dtox")
#self.dist2res = self.getCommandObject("dist2res")
#self.res2dist = self.getCommandObject("res2dist")
self.__resLimitsCallback = None
self.__resLimitsErrCallback = None
self.__resLimits = {}
#self.connect(self.device, "stateChanged", self.detmStateChanged)
#self.dist2res.connectSignal("commandReplyArrived", self.newResolution)
#self.res2dist.connectSignal("commandReplyArrived", self.newDistance)
def positionChanged(self, value):
res = self.dist2res(value)
try:
logging.getLogger("HWR").debug("%s: TangoResolution.positionChanged: %.3f", self.name(), res)
except:
logging.getLogger("HWR").error("%s: TangoResolution not responding, %s", self.name(), '')
self.emit('positionChanged', (res,))
def getState(self):
return TangoResolutionComplex.stateDict[str(self.device.State())]
def equipmentReady(self):
self.emit("deviceReady")
def equipmentNotReady(self):
self.emit("deviceNotReady")
def get_value(self):
return self.getPosition()
def getPosition(self):
#if self.currentResolution is None:
self.recalculateResolution()
return self.currentResolution
def energyChanged(self, energy,wave=None):
#logging.getLogger("HWR").debug(" %s energychanged : %.3f wave is %.3f", self.name(), energy,wave)
if self.currentEnergy is None:
self.currentEnergy = energy
if type(energy) is not float:
logging.getLogger("HWR").error("%s: TangoResolution Energy not a float: %s", energy, '')
return
if abs(self.currentEnergy - energy) > 0.0002:
self.currentEnergy = energy # self.blenergyHO.getCurrentEnergy()
self.wavelengthChanged(self.blenergyHO.getCurrentWavelength())
def wavelengthChanged(self, wavelength):
self.currentWavelength = wavelength
self.recalculateResolution()
def recalculateResolution(self):
self.currentDistance = self.device.position
self.currentResolution = self.dist2res(self.currentDistance)
if self.currentResolution is None:
return
self.newResolution(self.currentResolution)
def newResolution(self, res):
if self.currentResolution is None:
self.currentResolution = self.recalculateResolution()
logging.getLogger().info("new resolution = %.3f" % res)
self.currentResolution = res
self.emit("positionChanged", (res, ))
def connectNotify(self, signal):
#logging.getLogger("HWR").debug("%s: TangoResolution.connectNotify, : %s", \
# self.name(), signal)
if signal == "stateChanged":
self.stateChanged(self.getState())
#elif signal == 'limitsChanged':
# self.motorLimitsChanged()
elif signal == 'positionChanged':
self.positionChanged(self.device.position)
# self.setIsReady(True)
def stateChanged(self, state):
#logging.getLogger("HWR").debug("%s: TangoResolution.stateChanged: %s"\
# % (self.name(), state))
try:
self.emit('stateChanged', (TangoResolutionComplex.stateDict[str(state)], ))
except KeyError:
self.emit('stateChanged', (TangoResolutionComplex.stateDict['UNKNOWN'], )) #ms 2015-03-26 trying to get rid of the fatal error with connection to detector ts motor
def getLimits(self, callback=None, error_callback=None):
#low, high = self.device.getLimits("position")
# MS 18.09.2012 adapted for use without SimpleDevice
position_info = self.device.attribute_query("position")
low = float(position_info.min_value)
high = float(position_info.max_value)
logging.getLogger("HWR").debug("%s: DetectorDistance.getLimits: [%.2f - %.2f]"\
% (self.name(), low, high))
if callable(callback):
self.__resLimitsCallback = callback
self.__resLimitsErrCallback = error_callback
self.__resLimits = {}
rlow = self.dist2res(low, callback=self.__resLowLimitCallback, \
error_callback=self.__resLimitsErrCallback)
rhigh = self.dist2res(high, callback=self.__resHighLimitCallback,\
error_callback=self.__resLimitsErrCallback)
else:
#rlow, rhigh = map(self.dist2res, self.device.getLimits("position"))
# MS 18.09.2012 adapted for use without SimpleDevice
#rhigh = self.device.attribute_query("positon").max_value
rlow = self.dist2res(low)
rhigh = self.dist2res(high)
#position_info = self.device.attribute_query("position")
#rlow = float(position_info.min_value)
#rhigh = float(position_info.max_value)
logging.getLogger("HWR").debug("%s: TangoResolution.getLimits: [%.3f - %.3f]"\
% (self.name(), rlow, rhigh))
return (rlow, rhigh)
def isSpecConnected(self):
#logging.getLogger().debug("%s: TangoResolution.isSpecConnected()" % self.name())
return True
def __resLowLimitCallback(self, rlow):
self.__resLimits["low"]=float(rlow)
if len(self.__resLimits) == 2:
if callable(self.__resLimitsCallback):
self.__resLimitsCallback((self.__resLimits["low"], self.__resLimits["high"]))
self.__resLimitsCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def __resHighLimitCallback(self, rhigh):
self.__resLimits["high"]=float(rhigh)
if len(self.__resLimits) == 2:
if callable(self.__resLimitsCallback):
self.__resLimitsCallback((self.__resLimits["low"], self.__resLimits["high"]))
self.__resLimitsCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def __resLimitsErrCallback(self):
if callable(self.__resLimitsErrCallback):
self.__resLimitsErrCallback()
self.__resLimitsErrCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def move(self, res, mindist=114, maxdist=1000):
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
distance = self.res2dist(res)
if distance >= mindist and distance <= maxdist:
self.device.position = distance
elif distance < mindist:
logging.getLogger("user_level_log").warning("TangoResolution: requested resolution is above limit for specified energy, moving to maximum allowed resolution")
self.device.position = mindist
elif distance > maxdist:
logging.getLogger("user_level_log").warning("TangoResolution: requested resolution is below limit for specified energy, moving to minimum allowed resolution")
self.device.position = maxdist
def newDistance(self, dist):
self.device.position = dist
def motorIsMoving(self):
return self.device.state().name in ['MOVING', 'RUNNING']
def stop(self):
try:
self.device.Stop()
except:
logging.getLogger("HWR").err("%s: TangoResolution.stop: error while trying to stop!", self.name())
pass
def dist2res(self, Distance, callback=None, error_callback=None):
#Distance = float(Distance)# MS 2015-03-26 moving statement inside try loop
try:
Distance = float(Distance)
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
if self.currentWavelength is None:
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
thetaangle2 = math.atan(DETECTOR_DIAMETER/2./Distance)
Resolution = 0.5*self.currentWavelength /math.sin(thetaangle2/2.)
if callable(callback):
callback(Resolution)
return Resolution
except:
if callable(error_callback):
error_callback()
def dist2resWaveLenght(self,wavelength, Distance, callback=None, error_callback=None):
#Distance = float(Distance)# MS 2015-03-26 moving statement inside try loop
try:
#Distance = Distance
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
thetaangle2 = math.atan(DETECTOR_DIAMETER/2./Distance)
Resolution = 0.5*wavelength /math.sin(thetaangle2/2.)
if callable(callback):
callback(Resolution)
return Resolution
except:
if callable(error_callback):
error_callback()
def res2dist(self, Resolution):
#print "********* In res2dist with ", Resolution
Resolution = float(Resolution)
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
if self.currentWavelength is None:
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
thetaangle=math.asin(self.currentWavelength / 2. / Resolution)
Distance=DETECTOR_DIAMETER/2./math.tan(2.*thetaangle)
#print "********* Distance ", Distance
return Distance
class TangoResolution(BaseHardwareObjects.Equipment):
# resoState = {
# None: 'unknown',
# 'UNKNOWN': 'unknown',
# 'CLOSE': 'closed',
# 'OPEN': 'opened',
# 'MOVING': 'moving',
# 'FAULT': 'fault',
# 'DISABLE': 'disabled',
# 'OFF': 'fault',
# 'ON': 'unknown'
# }
stateDict = {
"UNKNOWN": 0,
"ALARM": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"1": 1,
"2": 2
}
def _init(self):
self.currentResolution = None
self.currentDistance = None
self.currentWavelength = None
self.currentEnergy = None
self.connect("equipmentReady", self.equipmentReady)
self.connect("equipmentNotReady", self.equipmentNotReady)
self.device = DeviceProxy(self.getProperty("tangoname"))
#self.monodevice = SimpleDevice(self.getProperty("tangoname2"), waitMoves = False, verbose=False)
self.blenergyHOname = self.getProperty("BLEnergy")
if self.blenergyHOname is None:
logging.getLogger("HWR").error(
'TangoResolution: you must specify the %s hardware object' %
self.blenergyHOname)
hobj = None
self.configOk = False
else:
hobj = HardwareRepository.HardwareRepository().getHardwareObject(
self.blenergyHOname)
if hobj is None:
logging.getLogger("HWR").error(
'TangoResolution: invalid %s hardware object' %
self.blenergyHOname)
self.configOk = False
self.blenergyHO = hobj
self.connect(self.blenergyHO, qt.PYSIGNAL('energyChanged'),
self.energyChanged)
# creer un chanel sur l'energy: pour faire un update
positChan = self.getChannelObject(
"position"
) # utile seulement si statechan n'est pas defini dans le code
positChan.connectSignal("update", self.positionChanged)
stateChan = self.getChannelObject(
"state"
) # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.stateChanged)
self.currentDistance = self.device.position
self.currentEnergy = self.blenergyHO.getCurrentEnergy()
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
return BaseHardwareObjects.Equipment._init(self)
def init(self):
#self.detm = self.getDeviceByRole("detm")
#self.dtox = self.getDeviceByRole("dtox")
#self.dist2res = self.getCommandObject("dist2res")
#self.res2dist = self.getCommandObject("res2dist")
self.__resLimitsCallback = None
self.__resLimitsErrCallback = None
self.__resLimits = {}
#self.connect(self.device, "stateChanged", self.detmStateChanged)
#self.dist2res.connectSignal("commandReplyArrived", self.newResolution)
#self.res2dist.connectSignal("commandReplyArrived", self.newDistance)
def positionChanged(self, value):
res = self.dist2res(value)
self.emit('positionChanged', (res, ))
def getState(self):
return TangoResolution.stateDict[str(self.device.State())]
def equipmentReady(self):
self.emit("deviceReady")
def equipmentNotReady(self):
self.emit("deviceNotReady")
def getPosition(self):
if self.currentResolution is None:
self.recalculateResolution()
return self.currentResolution
def energyChanged(self, energy):
if self.currentEnergy is None:
self.currentEnergy = energy
if type(energy) is not float:
logging.getLogger("HWR").error(
"%s: TangoResolution Energy not a float: %s", energy, '')
return
if abs(self.currentEnergy - energy) > 0.0002:
self.currentEnergy = energy # self.blenergyHO.getCurrentEnergy()
self.wavelengthChanged(self.blenergyHO.getCurrentWavelength())
def wavelengthChanged(self, wavelength):
self.currentWavelength = wavelength
self.recalculateResolution()
def recalculateResolution(self):
self.currentDistance = self.device.position
self.currentResolution = self.dist2res(self.currentDistance)
if self.currentResolution is None:
return
self.newResolution(self.currentResolution)
def newResolution(self, res):
if self.currentResolution is None:
self.currentResolution = self.recalculateResolution()
self.currentResolution = res
self.emit("positionChanged", (res, ))
def connectNotify(self, signal):
#logging.getLogger("HWR").debug("%s: TangoResolution.connectNotify, : %s", \
# self.name(), signal)
if signal == "stateChanged":
self.stateChanged(TangoResolution.stateDict[self.device.State])
elif signal == 'positionChanged':
self.positionChanged(self.device.position)
def stateChanged(self, state):
self.emit('stateChanged', (TangoResolution.stateDict[str(state)], ))
def getLimits(self, callback=None, error_callback=None):
positionChan = self.getChannelObject("position")
info = positionChan.getInfo()
high = float(info.max_value)
low = float(info.min_value)
#logging.getLogger("HWR").debug("%s: DetectorDistance.getLimits: [%.2f - %.2f]" % (self.name(), low, high))
if callable(callback):
#logging.getLogger("HWR").debug("getLimits with callback: %s" % callback)
self.__resLimitsCallback = callback
self.__resLimitsErrCallback = error_callback
self.__resLimits = {}
rlow = self.dist2res(low, callback=self.__resLowLimitCallback, \
error_callback=self.__resLimitsErrCallback)
rhigh = self.dist2res(high, callback=self.__resHighLimitCallback,\
error_callback=self.__resLimitsErrCallback)
else:
#logging.getLogger("HWR").debug("getLimits with no callback")
rhigh = self.dist2res(low)
rlow = self.dist2res(high)
#logging.getLogger("HWR").debug("%s: TangoResolution.getLimits: [%.3f - %.3f]"\
#% (self.name(), rlow, rhigh))
return (rlow, rhigh)
def isSpecConnected(self):
#logging.getLogger().debug("%s: TangoResolution.isSpecConnected()" % self.name())
return True
def __resLowLimitCallback(self, rlow):
self.__resLimits["low"] = float(rlow)
if len(self.__resLimits) == 2:
if callable(self.__resLimitsCallback):
self.__resLimitsCallback(
(self.__resLimits["low"], self.__resLimits["high"]))
self.__resLimitsCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def __resHighLimitCallback(self, rhigh):
self.__resLimits["high"] = float(rhigh)
if len(self.__resLimits) == 2:
if callable(self.__resLimitsCallback):
self.__resLimitsCallback(
(self.__resLimits["low"], self.__resLimits["high"]))
self.__resLimitsCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def __resLimitsErrCallback(self):
if callable(self.__resLimitsErrCallback):
self.__resLimitsErrCallback()
self.__resLimitsErrCallback = None
self.__dist2resA1 = None
self.__dist2resA2 = None
def move(self, res):
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
self.device.position = self.res2dist(res)
def newDistance(self, dist):
self.device.position = dist
def stop(self):
try:
self.device.Stop()
except:
logging.getLogger("HWR").err(
"%s: TangoResolution.stop: error while trying to stop!",
self.name())
pass
def dist2res(self, Distance, callback=None, error_callback=None):
Distance = float(Distance)
try:
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
if self.currentWavelength is None:
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
thetaangle2 = math.atan(DETECTOR_DIAMETER / 2. / Distance)
Resolution = 0.5 * self.currentWavelength / math.sin(
thetaangle2 / 2.)
if callable(callback):
callback(Resolution)
return Resolution
except:
if callable(error_callback):
error_callback()
def res2dist(self, Resolution):
#print "********* In res2dist with ", Resolution
Resolution = float(Resolution)
#Wavelength = self.monodevice._SimpleDevice__DevProxy.read_attribute("lambda").value
if self.currentWavelength is None:
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
thetaangle = math.asin(self.currentWavelength / 2. / Resolution)
Distance = DETECTOR_DIAMETER / 2. / math.tan(2. * thetaangle)
#print "********* Distance ", Distance
return Distance
class Attenuators(Device):
stateAttenuator = {'ALARM': 0, 'EXTRACT': 1, 'INSERT': 1, 'UNKNOWN': 3}
def __init__(self, name):
Device.__init__(self, name)
self.labels = []
self.bits = []
self.attno = 0
self.deviceOk = True
def init(self):
# cmdToggle = self.getCommandObject('toggle')
# cmdToggle.connectSignal('connected', self.connected)
# cmdToggle.connectSignal('disconnected', self.disconnected)
# Connect to device Attenuator defined "tangoname" in the xml file
try:
self.Attenuatordevice = DeviceProxy(self.getProperty("tangoname"))
except:
self.errorDeviceInstance(self.getProperty("tangoname"))
if self.deviceOk:
self.connected()
self.chanAttState = self.getChannelObject('State')
self.chanAttState.connectSignal('update', self.attStateChanged)
#self.chanAttFactor = self.getChannelObject('appliedTransmission')
self.chanAttFactor = self.getChannelObject('computedTransmission')
self.chanAttFactor.connectSignal('update', self.attFactorChanged)
#self.chanAttToggle = self.getChannelObject('filtersCombination')
#self.chanAttToggle.connectSignal('update', self.attToggleChanged)
self.getAtteConfig()
def getAtteConfig(self):
#logging.getLogger().debug("HOS Attenuator: passe dans getAtteConfig")
self.attno = len(self['atte'])
for att_i in range(self.attno):
obj = self['atte'][att_i]
self.labels.append(obj.label)
self.bits.append(obj.bits)
def getAttState(self):
#logging.getLogger().debug("HOS Attenuator: passe dans getAttState")
# logging.getLogger().debug("Attenuator state read from the device %s",self.Attenuatordevice.State)
try:
print "HEYO", self.Attenuatordevice.State
value = Attenuators.stateAttenuator[str(
self.Attenuatordevice.State())]
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not a integer value',
str(self.name()))
value = None
return value
def getAttFactor(self):
# logging.getLogger().debug("HOS Attenuator: passe dans getAttFactor")
try:
#value = float(self.Attenuatordevice.appliedTransmission)
print "HEY:", self.Attenuatordevice.computedTransmission
value = float(self.Attenuatordevice.computedTransmission)
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not a float value',
str(self.name()))
value = None
return value
def connected(self):
self.setIsReady(True)
def disconnected(self):
self.setIsReady(False)
def attStateChanged(self, channelValue):
# logging.getLogger("HWR").debug("%s: Attenuators.attStateChanged: %s", self.name(), channelValue)
self.emit('attStateChanged',
(Attenuators.stateAttenuator[str(channelValue)], ))
def attFactorChanged(self, channelValue):
try:
value = float(channelValue)
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not a float value',
str(self.name()))
else:
self.emit('attFactorChanged', (value, ))
def attToggleChanged(self, channelValue):
try:
value = int(channelValue)
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not a float value',
str(self.name()))
else:
self.emit('toggleFilter', (value, ))
def setTransmission(self, value):
logging.getLogger("HWR").debug("%s: Attenuators.setTransmission: %s",
self.name(), value)
try:
self.Attenuatordevice.computedAttenuation = 1.0 / (value / 100.0)
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not valid', str(self.name()))
value = None
return value
def toggle(self, value):
logging.getLogger().debug("HOS Attenuator: passe dans toggle")
# old_value = self.Attenuatordevice.filtersCombination
# try:
# self.Attenuatordevice.filtersCombination = old_value + (2**(value-1))
# except:
# logging.getLogger("HWR").error('%s: the filter doesn\'t exist', str(self.name()))
# value=None
return value
def errorDeviceInstance(self, device):
db = SimpleDevice("sys/database/dbds1")
logging.getLogger().error("Check Instance of Device server %s" %
db.DbGetDeviceInfo(device)[1][3])
self.sDisconnected()
class AttenuatorsPX2(Device):
stateAttenuator = {
'ALARM': 0,
'EXTRACT': 1,
'INSERT': 1,
'UNKNOWN': 3,
'ALARM': 'error',
'OFF': 'error',
'RUNNING': 'moving',
'MOVING': 'moving',
'STANDBY': 'ready',
'UNKNOWN': 'changed',
'EXTRACT': 'outlimits'
}
def __init__(self, name):
Device.__init__(self, name)
self.labels = []
self.bits = []
self.attno = 0
self.deviceOk = True
self.NumToLabel = {}
def init(self):
#cmdToggle = self.getCommandObject('toggle')
#cmdToggle.connectSignal('connected', self.connected)
#cmdToggle.connectSignal('disconnected', self.disconnected)
# Connect to device Attenuator defined "tangoname" in the xml file
try:
#self.Attenuatordevice = SimpleDevice(self.getProperty("tangoname"), verbose=False)
self.Attenuatordevice = DeviceProxy(self.getProperty("tangoname"))
self.Attenuatordevice.waitMoves = False
self.Attenuatordevice.timeout = 5000
except:
self.errorDeviceInstance(self.getProperty("tangoname"))
if self.deviceOk:
#self.connected()
#self.chanAttState = self.getChannelObject('State')
#print "self.chanAttState : ", self.chanAttState
#self.chanAttState.connectSignal('update', self.attStateChanged)
##self.chanAttFactor = self.getChannelObject('appliedTransmission')
##self.chanAttFactor = self.getChannelObject('computedTransmission')
##self.chanAttFactor.connectSignal('update', self.attFactorChanged)
##self.chanAttToggle = self.getChannelObject('filtersCombination')
##self.chanAttToggle.connectSignal('update', self.attToggleChanged)
#self.getAtteConfig()
self.connected()
self.chanAttState = self.getChannelObject('State')
print "self.chanAttState : ", self.chanAttState
self.chanAttState.connectSignal('update', self.attStateChanged)
#self.chanAttFactor = self.getChannelObject('appliedTransmission')
self.chanAttFactor = self.getChannelObject('Status')
self.chanAttFactor.connectSignal('update', self.attFactorChanged)
self.chanAttToggle = self.getChannelObject('State')
self.chanAttToggle.connectSignal('update', self.attToggleChanged)
self.getAtteConfig()
logging.getLogger().debug(
"AttenuatorsPX2: self.labels, self.bits, self.attno, %s, %s, %s" %
(self.labels, self.bits, self.attno))
def getAtteConfig(self):
pass
def getAtteConfig_OLD(self):
logging.getLogger().debug("HOS Attenuator: passe dans getAtteConfig")
self.attno = len(self['atte'])
for att_i in range(self.attno):
obj = self['atte'][att_i]
self.labels.append(obj.label)
self.bits.append(obj.bits)
self.NumToLabel = dict([(int(l.split()[0]), l) for l in self.labels])
def getAttState(self):
logging.getLogger().debug("HOS Attenuator: passe dans getAttState")
logging.getLogger().debug("Attenuator state read from the device %s",
self.Attenuatordevice.State().name)
try:
#print "HEYO", self.Attenuatordevice.StatefiltersCombination
print self.Attenuatordevice.Status()
value = AttenuatorsPX2.stateAttenuator[
self.Attenuatordevice.State().name]
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not a integer value',
str(self.name()))
value = None
return value
def getAttFactor(self):
logging.getLogger().debug("HOS Attenuator: passe dans getAttFactor")
print 'self.Attenuatordevice.Status()', self.Attenuatordevice.Status()
try:
#value = float(self.Attenuatordevice.appliedTransmission)
status = self.Attenuatordevice.Status()
status = status[:status.index(':')]
print 'status', status
value = status #self.Attenuatordevice.Status() #1. #float(self.Attenuatordevice.computedTransmission)
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not a float value',
str(self.name()))
value = None
return value
def connected(self):
self.setIsReady(True)
def disconnected(self):
self.setIsReady(False)
def attStateChanged(self, channelValue):
logging.getLogger("HWR").debug(
"%s: AttenuatorsPX2.attStateChanged: %s", self.name(),
channelValue)
self.emit('attStateChanged',
(AttenuatorsPX2.stateAttenuator[str(channelValue)], ))
def attFactorChanged(self, channelValue):
print 'attFactorChanged', channelValue
print 'self.Attenuatordevice.Status()', self.Attenuatordevice.Status()
try:
status = self.Attenuatordevice.Status()
status = status[:status.index(':')]
print 'status', status
value = status
#value = float(channelValue)
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not a float value',
str(self.name()))
else:
logging.getLogger("HWR").info(
'%s: AttenuatorsPX2, received value on channel',
str(self.name()))
self.emit('attFactorChanged', (value, ))
def attToggleChanged(self, channelValue):
# print "Dans attToggleChanged channelValue = %s" %channelValue
logging.getLogger().debug(
"HOS Attenuator: passe dans attToggleChanged")
try:
value = int(channelValue)
except:
logging.getLogger("HWR").error(
'%s: received value on channel is not a float value',
str(self.name()))
else:
self.emit('toggleFilter', (value, ))
def setTransmission(self, value):
logging.getLogger("HWR").debug(
"%s: AttenuatorsPX2.setTransmission: %s", self.name(), value)
print value
self.Attenuatordevice.write_attribute(
self.NumToLabel[value],
True) #.computedAttenuation = 1.0/(value/100.0)
#try:
#self.Attenuatordevice.write_attribute(value, True) #.computedAttenuation = 1.0/(value/100.0)
#except:
#logging.getLogger("HWR").error('%s: received value on channel is not valid', str(self.name()))
#value=None
return value
def toggle(self, value):
print "Toggle value = %s" % value
logging.getLogger().debug("HOS Attenuator: passe dans toggle")
self.Attenuatordevice.write_attribute(value, True)
# old_value = self.Attenuatordevice.filtersCombination
# try:
# self.Attenuatordevice.filtersCombination = old_value "sys/database/dbds1")+ (2**(value-1))
# except:
# logging.getLogger("HWR").error('%s: the filter doesn\'t exist', str(self.name()))
# value=None
return value
def errorDeviceInstance(self, device):
#db = SimpleDevice("sys/database/dbds1")
db = DeviceProxy("sys/database/dbds1")
logging.getLogger().error("Check Instance of Device server %s" %
db.DbGetDeviceInfo(device)[1][3])
self.sDisconnected()
class TangolightPneu(Device):
states = {
0: "out",
1: "in",
}
READ_CMD, READ_OUT = (0, 1)
def __init__(self, name):
Device.__init__(self, name)
#self.wagoidin = None
#self.wagoidout = None
self.wagokyin = None
self.wagokyout = None
#self.logic = 1
#self.readmode = WagoPneu.READ_OUT
self.wagoState = "unknown"
self.__oldValue = None
self.device = None
self.hutch = None
self.lastState = None
self.simulation = False
def init(self):
try:
self.device = DeviceProxy(self.getProperty("tangoname"))
except:
logging.getLogger("HWR").error("%s: unknown pss device name",
self.getProperty("tangoname"))
try:
self.device_beamstop = DeviceProxy(self.getProperty("tangoname2"))
except:
logging.getLogger("HWR").error("%s: unknown device name",
self.getProperty("tangoname2"))
try:
self.device_detdist = DeviceProxy(self.getProperty("tangoname3"))
except:
logging.getLogger("HWR").error("%s: unknown device name",
self.getProperty("tangoname3"))
if self.device and self.device_beamstop and self.device_detdist:
self.setIsReady(True)
def valueChanged(self, value):
state = self.getWagoState()
self.emit('wagoStateChanged', (state, ))
def getTangoState(self):
return str(self.device.State())
def getWagoState(self):
value = int(self.device.isInserted)
if value in TangolightPneu.states:
self.wagoState = TangolightPneu.states[value]
else:
self.wagoState = "unknown"
logging.getLogger("HWR").info("%s: TangolightPneu.getWagoState, %s",
self.name(), self.wagoState)
return self.wagoState
def wagoIn(self):
logging.getLogger("HWR").info("%s: TangolightPneu.wagoIn", self.name())
if self.isReady():
if self.simulation == True:
self.device.isInserted = True
else:
# PL. 2010.01.22: Les etats du DS BPS ne sont pas mis a jour pour l'instant.
# Il n'y a pas de butees pour cela. On force donc l'extraction du BStop.
if str(self.device_beamstop.State()) != "EXTRACT":
self.device_beamstop.Extract()
while str(self.device_beamstop.State()) != "EXTRACT":
qApp.processEvents()
#qApp.processEvents()
detposition = self.device_detdist.position
min_detposition = 269.5
if detposition < min_detposition:
msg = "Can't insert Light-arm, detector distance too close:"
msg += "%.1f You need to set the distance to > %.1f mm." %\
(detposition, min_detposition)
logging.getLogger("HWR").error("%s: " + msg, self.name())
return
time.sleep(0.2)
self.device.Insert()
timeout = 0
while self.getTangoState() != "INSERT":
time.sleep(0.2)
timeout += 0.2
if timeout >= 4.0:
break
if self.getTangoState() != "INSERT":
logging.getLogger("HWR").error(
"%s: LIGHT ARM NOT CORRECTLY INSERTED", self.name())
def wagoOut(self):
logging.getLogger("HWR").info("%s: TangolightPneu.wagoOut",
self.name())
if self.isReady():
if self.simulation == True:
self.device.isInserted = False
else:
self.device.Extract()
pass
class TangoMotor3(Device):
stateDict = {
"UNKNOWN": 0,
"ALARM": 1,
"FAULT": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"ON": 2,
'2': 2}
def __init__(self, name):
Device.__init__(self, name)
self.GUIstep = 0.1
def _init(self):
self.MOVESTARTED = 0
self.NOTINITIALIZED = 0
self.UNUSABLE = 0
self.READY = 2
self.MOVING = 4
self.ONLIMITS = 1
self.device = DeviceProxy(self.getProperty("tangoname"))
self.device.waitMoves = False
self.setIsReady(True)
print("TangoMotor._init of device %s" % self.device.name)
self.positionChan = self.getChannelObject("attributeName") # utile seulement si statechan n'est pas defini dans le code
self.positionChan.connectSignal("update", self.positionChanged)
self.stateChan = self.getChannelObject("state") # utile seulement si statechan n'est pas defini dans le code
self.stateChan.connectSignal("update", self.stateChanged)
#
# logging.getLogger("HWR").info("%s: TangoMotor._init, %s", self.name(), '')
def positionChanged(self, value):
try:
logging.getLogger("HWR").info("%s: TangoMotor.positionChanged: %.3f", self.name(), value)
except:
logging.getLogger("HWR").error("%s: TangoMotor not responding, %s", self.name(), '')
self.emit('positionChanged', (value,))
def isReady(self):
#logging.getLogger("HWR").info("%s: TangoMotor.isReady", self.name())
return self.motorState() == TangoMotor3.stateDict["STANDBY"]
def connectNotify(self, signal):
#logging.getLogger("HWR").info("%s: TangoMotor.connectNotify, : %s", \
# self.name(), signal)
if signal == 'hardwareObjectName,stateChanged':
self.motorStateChanged(self.motorState())
elif signal == 'limitsChanged':
self.motorLimitsChanged()
#print "Not implemented yet."
elif signal == 'positionChanged':
self.motorPositionChanged(self.positionChan.getValue())
self.setIsReady(True)
def motorState(self):
return self.getState()
def stateChanged(self, state):
logging.getLogger("HWR").info("State Changed, %s / %s" % (self.name(), str(state)))
self.motorStateChanged(state)
def motorStateChanged(self, state):
logging.getLogger("HWR").info("%s: TangoMotor.motorStateChanged, %s", self.name(), state)
#self.setIsReady(state == 'STANDBY')
self.setIsReady(True)
print("motorStateChanged", str(state),self.motorState())
self.emit('stateChanged', (self.motorState(), ))
def getState(self):
state = str(self.device.State())
#logging.getLogger("HWR").info("%s: TangoMotor.getState, %s", self.name(), state)
#return self.motorState()
return TangoMotor3.stateDict[ state ]
def getLimits(self):
#limits = self.device.getLimits(str(self.positionChan.attributeName))
try:
atprops = self.device.attribute_query(str(self.positionChan.attributeName))
limits = list(map(float, [atprops.min_value, atprops.max_value]))
logging.getLogger("HWR").info("TangoMotor3 getLimits returning %.4f %.4f" % (limits[0], limits[1]))
return limits
except IndexError:
logging.getLogger("HWR").info("TangoMotor3 cannot getLimits returning -1,1" )
return (-1,1)
def motorLimitsChanged(self):
#self.emit('limitsChanged', (self.getLimits(), ))
#logging.getLogger("HWR").info("%s: TangoMotor.limitsChanged", self.name())
self.emit('limitsChanged', (self.getLimits(), ))
def motorMoveDone(self, channelValue):
#SpecMotorA.motorMoveDone(self, channelValue)
#logging.getLogger("HWR").info("TangoMotor.motorMoveDone")
if str(self.device.State()) == 'STANDBY':
#self.emit('moveDone', (self.specversion, self.specname, ))
self.emit('moveDone', ("EH3","toto" ))
def motorPositionChanged(self, absolutePosition):
self.motorStateChanged(self.device.State())
self.emit('positionChanged', (absolutePosition, ))
def syncQuestionAnswer(self, specSteps, controllerSteps):
return '0' #NO ('1' means YES)
def getPosition(self):
pos = self.positionChan.getValue()
#logging.getLogger("HWR").info("%s: TangoMotor.getPosition, pos = %.3f", self.name(), pos)
return pos
def syncMove(self, position):
#print 'about to start moving', self.motorState
import time; t0=time.time()
prev_position = self.getPosition()
self.positionChan.value = position
print('move started from %s to %s, state is %s' % (prev_position, position, self.getState()))
while self.getState() == "RUNNING" or self.getState() == "MOVING": # or str(self.device.State()) == SpecMotor.MOVESTARTED:
#print 'processing events...', self.motorState
qApp.processEvents(100)
print('move done (%s s), state is %s' % (time.time()-t0, str(self.device.State())))
def syncMoveRelative(self, position):
old_pos = self.positionChan.getValue()
self.positionChan.value = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while self.getState() == "RUNNING" or self.getState() == "MOVING":
qApp.processEvents(100)
def moveRelative(self, position):
old_pos = self.positionChan.getValue()
self.positionChan.value = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
self.syncMove(self.positionChan.value)
def getMotorMnemonic(self):
return self.specName
def move(self, absolutePosition):
"""Move the motor to the required position
Arguments:
absolutePosition -- position to move to
"""
if type(absolutePosition) != float and type(absolutePosition) != int:
logging.getLogger("TangoClient").error("Cannot move %s: position '%s' is not a number", self.device.name, absolutePosition)
#self.__changeMotorState(MOVESTARTED)
#c = self.connection.getChannel(self.chanNamePrefix % 'start_one')
logging.getLogger("HWR").info("TangoMotor.move to absolute position: %.3f" % absolutePosition)
self.positionChan.value = absolutePosition
print(self.positionChan.value)
nom_attribut=self.positionChan.attributeName
setattr(self.device,nom_attribut,absolutePosition)
self.motorPositionChanged(absolutePosition)
def stop(self):
logging.getLogger("HWR").info("TangoMotor.stop")
self.device.Stop()
def isSpecConnected(self):
logging.getLogger().debug("%s: TangoMotor.isSpecConnected()" % self.name())
return TruehardwareObjectName,
class Ps_attenuatorPX1(Device):
stateAttenuator = {
'ALARM': 'error',
'OFF': 'error',
'RUNNING': 'moving',
'MOVING': 'moving',
'STANDBY': 'ready',
'UNKNOWN': 'changed',
'EXTRACT': 'outlimits'
}
def __init__(self, name):
Device.__init__(self, name)
self.labels = []
self.attno = 0
self.deviceOk = True
def init(self):
# cmdToggle = self.getCommandObject('toggle')
# cmdToggle.connectSignal('connected', self.connected)
# cmdToggle.connectSignal('disconnected', self.disconnected)
# Connect to device FP_Parser defined "tangoname" in the xml file
try:
self.Attenuatordevice = DeviceProxy(self.getProperty("tangoname"))
except:
self.errorDeviceInstance(self.getProperty("tangoname"))
if self.deviceOk:
self.connected()
self.chanAttState = self.getChannelObject('State')
self.chanAttState.connectSignal('update', self.attStateChanged)
self.chanAttFactor = self.getChannelObject('TrueTrans_FP')
self.chanAttFactor.connectSignal('update', self.attFactorChanged)
def getAttState(self):
logging.getLogger().info("HOS Attenuator: passe dans getAttState")
try:
value = Ps_attenuatorPX1.stateAttenuator[
self.Attenuatordevice.State().name]
print 'State Ps_Attenuator : ', Ps_attenuatorPX1.stateAttenuator[
self.Attenuatordevice.State().name]
logging.getLogger().debug(
"Attenuator state read from the device %s", value)
except:
logging.getLogger("HWR").error(
'%s getAttState : received value on channel is not a integer value',
str(self.name()))
value = None
return value
def attStateChanged(self, channelValue):
logging.getLogger().info("HOS Attenuator: passe dans attStateChanged")
value = self.getAttState()
self.emit('attStateChanged', (value, ))
def getAttFactor(self):
logging.getLogger().info("HOS Attenuator: passe dans getAttFactor")
try:
# if self.Attenuatordevice.TrueTrans_FP <= 100.0 :
# value = float(self.Attenuatordevice.TrueTrans_FP)
# else :
# value = float(self.Attenuatordevice.T)
value = float(self.Attenuatordevice.TrueTrans_FP)
except:
logging.getLogger("HWR").error(
'%s getAttFactor : received value on channel is not a float value',
str(self.name()))
value = None
return value
def connected(self):
self.setIsReady(True)
def disconnected(self):
self.setIsReady(False)
def attFactorChanged(self, channelValue):
try:
print "Dans attFactorChanged channelValue = %f" % channelValue
# value = float(channelValue)
value = self.getAttFactor()
except:
logging.getLogger("HWR").error(
'%s attFactorChanged : received value on channel is not a float value',
str(self.name()))
else:
self.emit('attFactorChanged', (value, ))
def attToggleChanged(self, channelValue):
# print "Dans attToggleChanged channelValue = %s" %channelValue
# logging.getLogger().debug("HOS Attenuator: passe dans attToggleChanged")
try:
value = int(channelValue)
except:
logging.getLogger("HWR").error(
'%s attToggleChanged : received value on channel is not a float value',
str(self.name()))
else:
self.emit('toggleFilter', (value, ))
def setTransmission(self, value):
logging.getLogger().debug("HOS Attenuator: passe dans setTransmission")
try:
self.Attenuatordevice.TrueTrans_FP = value
except:
logging.getLogger("HWR").error(
'%s set Transmission : received value on channel is not valid',
str(self.name()))
value = None
return value
def toggle(self, value):
logging.getLogger().debug("HOS Attenuator: passe dans toggle")
return value
def errorDeviceInstance(self, device):
db = DeviceProxy("sys/database/dbds1")
logging.getLogger().error("Check Instance of Device server %s" %
db.DbGetDeviceInfo(device)[1][3])
self.sDisconnected()
class EnergyScanPX1(Equipment):
MANDATORY_HO={"BLEnergy":"BLEnergy"}
def init(self):
self.scanning = None
# self.moving = None
self.scanThread = None
self.pk = None
self.ip = None
self.roiwidth = 0.35 # en keV largeur de la roi
self.before = 0.10 # en keV Ecart par rapport au seuil pour le point de depart du scan
self.after = 0.20 # en keV Ecart par rapport au seuil pour le dernier point du scan
self.canScan = True
self.nbsteps = 100 #
self.integrationtime = 5.0
self.directoryPrefix = None
self.directoryPrefix=self.getProperty("directoryprefix")
if self.directoryPrefix is None:
logging.getLogger("HWR").error("EnergyScan: you must specify the directory prefix property")
else :
logging.getLogger("HWR").info("EnergyScan: directoryPrefix : %s" %(self.directoryPrefix))
# Load mandatory hardware objects
# for ho in EnergyScan.MANDATORY_HO:
# desc=EnergyScan.MANDATORY_HO[ho]
# name=self.getProperty(ho)
# if name is None:
# logging.getLogger("HWR").error('EnergyScan: you must specify the %s hardware object' % desc)
# hobj=None
# self.configOk=False
# else:
# hobj=HardwareRepository.HardwareRepository().getHardwareObject(name)
# if hobj is None:
# logging.getLogger("HWR").error('EnergyScan: invalid %s hardware object' % desc)
# self.configOk=False
# exec("self.%sHO=hobj" % ho)
#
# print "BLEnergyHO : ", self.BLEnergyHO
paramscan = self["scan"]
self.roiwidth = paramscan.roiwidth
self.before = paramscan.before
self.after = paramscan.after
self.nbsteps = paramscan.nbsteps
self.integrationTime = paramscan.integrationtime
print("self.roiwidth :", self.roiwidth)
print("self.before :", self.before)
print("self.after :", self.after)
print("self.nbsteps :", self.nbsteps)
print("self.integrationtime :", self.integrationtime)
self.dbConnection=self.getObjectByRole("dbserver")
if self.dbConnection is None:
logging.getLogger("HWR").warning('EnergyScan: you should specify the database hardware object')
self.scanInfo=None
if self.isSpecConnected():
self.sConnected()
def connectTangoDevices(self):
try :
self.BLEnergydevice = DeviceProxy(self.getProperty("blenergy")) #, verbose=False)
self.BLEnergydevice.waitMoves = True
self.BLEnergydevice.timeout = 30000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("blenergy")))
self.canScan = False
# Connect to device mono defined "tangoname2" in the xml file
# used for conversion in wavelength
try :
self.monodevice = DeviceProxy(self.getProperty("mono")) #, verbose=False)
self.monodevice.waitMoves = True
self.monodevice.timeout = 6000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("mono")))
self.canScan = False
#mono_mt_rx
try :
self.mono_mt_rx_device = DeviceProxy(self.getProperty("mono_mt_rx")) #, verbose=False)
#self.monodevice.waitMoves = True
self.mono_mt_rx_device.timeout = 6000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("mono_mt_rx")))
self.canScan = False
# Nom du device bivu (Energy to gap) : necessaire pour amelioration du positionnement de l'onduleur (Backlash)
try :
self.U20Energydevice = DeviceProxy(self.getProperty("U24Energy")) #, movingState="MOVING")
self.U20Energydevice.timeout = 30000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("U24Energy")))
self.canScan = False
try :
self.fluodetdevice = DeviceProxy(self.getProperty("ketek")) #, verbose=False)
self.fluodetdevice.timeout = 1000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("ketek")))
self.canScan = False
try :
self.counterdevice = DeviceProxy(self.getProperty("counter")) #, verbose=False)
self.counterdevice.timeout = 1000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("counter")))
self.canScan = False
try :
self.xbpmdevice = DeviceProxy(self.getProperty("xbpm")) #, verbose=False)
self.xbpmdevice.timeout = 30000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("xbpm")))
self.canScan = False
try :
self.attdevice = DeviceProxy(self.getProperty("attenuator")) #, verbose=False)
self.attdevice.timeout = 6000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("attenuator")))
self.canScan = False
# try :
# self.md2device = DeviceProxy(self.getProperty("md2")) #, verbose=False)
# self.md2device.timeout = 2000
# except :
# logging.getLogger("HWR").error("%s not found" %(self.getProperty("md2")))
# self.canScan = False
try:
self.lightdevice = DeviceProxy(self.getProperty("lightextract")) #, verbose=False)
self.lightdevice.timeout = 2000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("lightextract")))
self.canScan = False
try:
self.bstdevice = DeviceProxy(self.getProperty("bst")) #, verbose=False)
self.bstdevice.timeout = 2000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("bst")))
self.canScan = False
try:
self.ketekinsertdevice = DeviceProxy(self.getProperty("ketekinsert")) #, verbose=False)
self.ketekinsertdevice.timeout = 2000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("ketekinsert")))
self.canScan = False
try:
self.fastshutterdevice = DeviceProxy(self.getProperty("fastshutter")) #, verbose=False)
self.fastshutterdevice.timeout = 2000
except :
logging.getLogger("HWR").error("%s not found" %(self.getProperty("fastshutter")))
self.canScan = False
def isConnected(self):
return self.isSpecConnected()
def isSpecConnected(self):
logging.getLogger("HWR").debug('EnergyScan:isSpecConnected')
return True
# Handler for spec connection
def sConnected(self):
logging.getLogger("HWR").debug('EnergyScan:sConnected')
self.emit('connected', ())
self.emit('setDirectory', (self.directoryPrefix,))
# Handler for spec disconnection
def sDisconnected(self):
logging.getLogger("HWR").debug('EnergyScan:sDisconnected')
self.emit('disconnected', ())
# Energy scan commands
def canScanEnergy(self):
logging.getLogger("HWR").debug('EnergyScan:canScanEnergy : %s' %(str(self.canScan)))
return self.canScan
# return self.doEnergyScan is not None
def startEnergyScan(self,
element,
edge,
directory,
prefix,
session_id = None,
blsample_id = None):
logging.getLogger("HWR").debug('EnergyScan:startEnergyScan')
print('edge', edge)
print('element', element)
print('directory', directory)
print('prefix', prefix)
#logging.getLogger("HWR").debug('EnergyScan:edge', edge)
#logging.getLogger("HWR").debug('EnergyScan:element', element)
#logging.getLogger("HWR").debug('EnergyScan:directory', directory)
#logging.getLogger("HWR").debug('EnergyScan:prefix', prefix)
#logging.getLogger("HWR").debug('EnergyScan:edge', edge)
self.scanInfo={"sessionId":session_id,
"blSampleId":blsample_id,
"element":element,
"edgeEnergy":edge}
# if self.fluodetectorHO is not None:
# self.scanInfo['fluorescenceDetector']=self.fluodetectorHO.userName()
if not os.path.isdir(directory):
logging.getLogger("HWR").debug("EnergyScan: creating directory %s" % directory)
try:
os.makedirs(directory)
except OSError as diag:
logging.getLogger("HWR").error("EnergyScan: error creating directory %s (%s)" % (directory,str(diag)))
self.emit('scanStatusChanged', ("Error creating directory",))
return False
self.doEnergyScan(element, edge, directory, prefix)
return True
def cancelEnergyScan(self):
logging.getLogger("HWR").debug('EnergyScan:cancelEnergyScan')
if self.scanning:
self.scanning = False
def scanCommandReady(self):
logging.getLogger("HWR").debug('EnergyScan:scanCommandReady')
if not self.scanning:
self.emit('energyScanReady', (True,))
def scanCommandNotReady(self):
logging.getLogger("HWR").debug('EnergyScan:scanCommandNotReady')
if not self.scanning:
self.emit('energyScanReady', (False,))
def scanCommandStarted(self):
logging.getLogger("HWR").debug('EnergyScan:scanCommandStarted')
self.scanInfo['startTime']=time.strftime("%Y-%m-%d %H:%M:%S")
self.scanning = True
self.emit('energyScanStarted', ())
def scanCommandFailed(self):
logging.getLogger("HWR").debug('EnergyScan:scanCommandFailed')
self.scanInfo['endTime']=time.strftime("%Y-%m-%d %H:%M:%S")
self.scanning = False
self.storeEnergyScan()
self.emit('energyScanFailed', ())
def scanCommandAborted(self):
logging.getLogger("HWR").debug('EnergyScan:scanCommandAborted')
def scanCommandFinished(self,result):
logging.getLogger("HWR").debug("EnergyScan: energy scan result is %s" % result)
self.scanInfo['endTime']=time.strftime("%Y-%m-%d %H:%M:%S")
self.scanning = False
if result==-1:
self.storeEnergyScan()
self.emit('scanStatusChanged', ("Scan aborted",))
self.emit('energyScanFailed', ())
return
self.storeEnergyScan()
self.emit('energyScanFinished', (self.scanInfo,))
self.scanInfo=None
def doChooch(self, scanObject, scanDesc):
#elt,
#edge):
#scanArchiveFilePrefix = 'scanArchiveFilePrefix',
#scanFilePrefix = 'scanFilePrefix'):
logging.getLogger().info("EnergyScan: doChooch")
print('scanObject', scanObject)
print('scanDesc', scanDesc)
#archiveRawScanFile=os.path.extsep.join((scanArchiveFilePrefix, "raw"))
#rawScanFile=os.path.extsep.join((scanFilePrefix, "raw"))
#scanFile=os.path.extsep.join((scanFilePrefix, "efs"))
#if not os.path.exists(os.path.dirname(scanArchiveFilePrefix)):
#os.mkdir(os.path.dirname(scanArchiveFilePrefix))
#try:
#f=open(rawScanFile, "w")
#pyarch_f=open(archiveRawScanFile, "w")
#except:
#logging.getLogger("HWR").exception("could not create raw scan files")
#self.storeEnergyScan()
#self.emit("energyScanFailed", ())
#return
#else:
#scanData = []
#for i in range(len(scanObject.x)):
#x = float(scanObject.x[i])
#x = x < 1000 and x*1000.0 or x
#y = float(scanObject.y[i])
#scanData.append((x, y))
#f.write("%f,%f\r\n" % (x, y))
#pyarch_f.write("%f,%f\r\n"% (x, y))
#f.close()
#pyarch_f.close()
#self.scanInfo["scanFileFullPath"]=str(archiveRawScanFile)
filenameIn = self.filenameIn
filenameOut = filenameIn[:-3] + 'efs'
scanData = []
contents = file(filenameIn).readlines()
file(filenameIn).close()
for value in contents:
if value[0] != '#' :
vals = value.split()
x = float(vals[0])
x = x < 1000 and x*1000.0 or x #This is rather cryptic but seems to work (MS 11.03.13)
y = float(vals[1])
#if y == 0.0:
#self.scanCommandFailed()
#self.scanStatus.setText("data not valid for chooch")
#print "data not valid for chooch"
#return
scanData.append((x, y))
elt = scanDesc['element']
edge = scanDesc['edgeEnergy']
try:
pk, fppPeak, fpPeak, ip, fppInfl, fpInfl, chooch_graph_data = PyChooch.calc(scanData,
elt,
edge,
filenameOut)
except:
pk = self.thEdge
rm = (pk + 50.) / 1000.0
savpk = pk
ip = pk - 5. / 1000.0
logging.getLogger("HWR").info("Chooch failed badly")
#, fppPeak, fpPeak, ip, fppInfl, fpInfl, chooch_graph_data = self.thEdge,
rm = (pk + 50.) / 1000.0
pk = pk / 1000.0
savpk = pk
ip = ip / 1000.0
comm = ""
logging.getLogger("HWR").info("th. Edge %s ; chooch results are pk=%f, ip=%f, rm=%f" % (self.thEdge, pk, ip, rm))
if math.fabs(self.thEdge - ip) > 0.01:
pk = 0
ip = 0
rm = self.thEdge + 0.05
comm = 'Calculated peak (%f) is more that 10eV away from the theoretical value (%f). Please check your scan' % (savpk, self.thEdge)
logging.getLogger("HWR").warning('EnergyScan: calculated peak (%f) is more that 10eV %s the theoretical value (%f). Please check your scan and choose the energies manually' % (savpk, (self.thEdge - ip) > 0.01 and "below" or "above", self.thEdge))
scanFile = filenameIn
archiveEfsFile = filenameOut #os.path.extsep.join((scanArchiveFilePrefix, "efs"))
try:
fi = open(scanFile)
fo = open(archiveEfsFile, "w")
except:
self.storeEnergyScan()
self.emit("energyScanFailed", ())
return
else:
fo.write(fi.read())
fi.close()
fo.close()
self.scanInfo["peakEnergy"]=pk
self.scanInfo["inflectionEnergy"]=ip
self.scanInfo["remoteEnergy"]=rm
self.scanInfo["peakFPrime"]=fpPeak
self.scanInfo["peakFDoublePrime"]=fppPeak
self.scanInfo["inflectionFPrime"]=fpInfl
self.scanInfo["inflectionFDoublePrime"]=fppInfl
self.scanInfo["comments"] = comm
chooch_graph_x, chooch_graph_y1, chooch_graph_y2 = list(zip(*chooch_graph_data))
chooch_graph_x = list(chooch_graph_x)
for i in range(len(chooch_graph_x)):
chooch_graph_x[i]=chooch_graph_x[i]/1000.0
logging.getLogger("HWR").info("<chooch> Saving png" )
# prepare to save png files
title="%10s %6s %6s\n%10s %6.2f %6.2f\n%10s %6.2f %6.2f" % ("energy", "f'", "f''", pk, fpPeak, fppPeak, ip, fpInfl, fppInfl)
fig=Figure(figsize=(15, 11))
ax=fig.add_subplot(211)
ax.set_title("%s\n%s" % (scanFile, title))
ax.grid(True)
ax.plot(*(list(zip(*scanData))), **{"color":'black'})
ax.set_xlabel("Energy")
ax.set_ylabel("MCA counts")
ax2=fig.add_subplot(212)
ax2.grid(True)
ax2.set_xlabel("Energy")
ax2.set_ylabel("")
handles = []
handles.append(ax2.plot(chooch_graph_x, chooch_graph_y1, color='blue'))
handles.append(ax2.plot(chooch_graph_x, chooch_graph_y2, color='red'))
canvas=FigureCanvasAgg(fig)
escan_png = filenameOut[:-3] + 'png' #.replace('.esf', '.png') #os.path.extsep.join((scanFilePrefix, "png"))
escan_archivepng = filenameOut[:-4] + '_archive.png' #os.path.extsep.join((scanArchiveFilePrefix, "png"))
self.scanInfo["jpegChoochFileFullPath"]=str(escan_archivepng)
try:
logging.getLogger("HWR").info("Rendering energy scan and Chooch graphs to PNG file : %s", escan_png)
canvas.print_figure(escan_png, dpi=80)
except:
logging.getLogger("HWR").exception("could not print figure")
try:
logging.getLogger("HWR").info("Saving energy scan to archive directory for ISPyB : %s", escan_archivepng)
canvas.print_figure(escan_archivepng, dpi=80)
except:
logging.getLogger("HWR").exception("could not save figure")
self.storeEnergyScan()
self.scanInfo=None
logging.getLogger("HWR").info("<chooch> returning" )
return pk, fppPeak, fpPeak, ip, fppInfl, fpInfl, rm, chooch_graph_x, chooch_graph_y1, chooch_graph_y2, title
def scanStatusChanged(self,status):
logging.getLogger("HWR").debug('EnergyScan:scanStatusChanged')
self.emit('scanStatusChanged', (status,))
def storeEnergyScan(self):
logging.getLogger("HWR").debug('EnergyScan:storeEnergyScan')
#if self.dbConnection is None:
#return
#try:
#session_id=int(self.scanInfo['sessionId'])
#except:
#return
return
def updateEnergyScan(self, scan_id, jpeg_scan_filename):
logging.getLogger("HWR").debug('EnergyScan:updateEnergyScan')
# Elements commands
def getElements(self):
logging.getLogger("HWR").debug('EnergyScan:getElements')
elements=[]
try:
for el in self["elements"]:
elements.append({"symbol":el.symbol, "energy":el.energy})
except IndexError:
pass
return elements
# Mad energies commands
def getDefaultMadEnergies(self):
logging.getLogger("HWR").debug('EnergyScan:getDefaultMadEnergies')
energies=[]
try:
for el in self["mad"]:
energies.append([float(el.energy), el.directory])
except IndexError:
pass
return energies
def getFilename(self, directory, filename, element, edge):
filenameIn = os.path.join(directory, filename)
filenameIn += "_" + element + "_" + "_".join(edge) + ".dat"
return filenameIn
def doEnergyScan(self, element, edge, directory, filename):
logging.getLogger("HWR").info('EnergyScan: Element:%s Edge:%s' %(element,edge))
e_edge, roi_center = self.getEdgefromXabs(element, edge)
self.thEdge = e_edge
self.element = element
self.edge = edge
print('e_edge = %5.4f , roi_center = %5.4f' %(e_edge, roi_center))
filenameIn = self.getFilename(directory, filename, element, edge) # filenameIn
self.filenameIn = filenameIn
# Demarrage du thread de scan
self.scanCommandStarted()
self.pk = None
self.ip = None
self.scanThread = EnergyScanThread(self,
e_edge,
roi_center,
filenameIn)
self.scanThread.start()
def getEdgefromXabs(self, el, edge):
edge = string.upper(edge)
roi_center = McMaster[el]['edgeEnergies'][edge + '-alpha']
if edge == 'L':
edge = 'L3'
e_edge = McMaster[el]['edgeEnergies'][edge]
return (e_edge, roi_center)
def newPoint(self, x, y):
logging.getLogger("HWR").debug('EnergyScan:newPoint')
print('newPoint', x, y)
self.emit('addNewPoint', (x, y))
def newScan(self,scanParameters):
logging.getLogger("HWR").debug('EnergyScan:newScan')
self.emit('newScan', (scanParameters,))
def startMoveEnergy(self, value): # Copie du code ecrit dans BLEnergy.py pour gestion du backlash onduleur.
# MODIFICATION DE CETTE FONCTION POUR COMPENSER LE PROBLEME D'HYSTERESIS DE L"ONDULEUR
# PAR CETTE METHODE ON APPLIQUE TOUJOURS UN GAP CROISSANT
backlash = 0.1 # en mmte
gaplimite = 5.5 # en mm
self.doBacklashCompensation = False # True #MS 2013-05-21
# self.mono_mt_rx_device.On()
#time.sleep(5)
if (str(self.BLEnergydevice.State()) != "MOVING") :# MS .State -> .State() 06.03.2013
if self.doBacklashCompensation :
try :
# Recuperation de la valeur de gap correspondant a l'energie souhaitee
self.U20Energydevice.autoApplyComputedParameters = False
self.U20Energydevice.energy = value
newgap = self.U20Energydevice.computedGap
actualgap = self.U20Energydevice.gap
self.U20Energydevice.autoApplyComputedParameters = True
# On applique le backlash que si on doit descendre en gap
if newgap < actualgap + backlash:
# Envoi a un gap juste en dessous (backlash)
if newgap-backlash > gaplimite :
self.U20Energydevice.gap = newgap - backlash
else :
self.U20Energydevice.gap = gaplimite
self.U20Energydevice.gap = newgap + backlash
time.sleep(1)
except :
logging.getLogger("HWR").error("%s: Cannot move undulator U20 : State device = %s", self.name(), self.U20Energydevice.State())
try :
# Envoi a l'energie desiree
self.BLEnergydevice.energy = value
except :
logging.getLogger("HWR").error("%s: Cannot move BLEnergy : State device = %s", self.name(), self.BLEnergydevice.State())
else :
statusBLEnergydevice = self.BLEnergydevice.Status()
logging.getLogger("HWR").error("%s: Cannot move : State device = %s", self.name(), self.BLEnergydevice.State())
for i in statusBLEnergydevice.split("\n") :
logging.getLogger().error("\t%s\n" % i)
logging.getLogger().error("\tCheck devices")
# Envoi a l'energie desiree
# self.BLEnergydevice.energy = value
def getChoochValue(self, pk, ip) :
logging.getLogger("HWR").debug('EnergyScan:getChoochValue')
self.pk = pk
self.ip = ip
class TangoMotorZoomPX2(Device):
stateDict = {
"UNKNOWN": 0,
"ALARM": 1,
"FAULT": 1,
"STANDBY": 2,
"RUNNING": 4,
"MOVING": 4,
"ON": 2,
'2': 2
}
def __init__(self, name):
Device.__init__(self, name)
self.GUIstep = 0.1
def _init(self):
self.MOVESTARTED = 0
self.NOTINITIALIZED = 0
self.UNUSABLE = 0
self.READY = 2
self.MOVING = 4
self.ONLIMITS = 1
#self.device = SimpleDevice(self.getProperty("tangoname"), verbose=False)
#self.device.timeout = 6000 # Setting timeout to 6 sec
self.device = DeviceProxy(self.getProperty("tangoname"))
self.device.waitMoves = False
logging.getLogger("HWR").info("TangoMotorZoomPX2._init of device %s" %
self.device.name)
self.setIsReady(True)
print("TangoMotorZoomPX2._init of device %s" % self.device.name)
positionChan = self.getChannelObject(
"position"
) # utile seulement si statechan n'est pas defini dans le code
positionChan.connectSignal("update", self.positionChanged)
#focus_positionChan = self.getChannelObject("focus_position")
#focus_positionChan.connectSignal("update", self.positionChanged)
stateChan = self.getChannelObject(
"state"
) # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.motorStateChanged)
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2._init, %s", self.name(), '')
def positionChanged(self, value):
try:
logging.getLogger("HWR").info(
"%s: TangoMotorZoomPX2.positionChanged: %.3f", self.name(),
value)
except:
logging.getLogger("HWR").error("%s: TangoMotor not responding, %s",
self.name(), '')
self.emit('positionChanged', (value, ))
def isReady(self):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.isReady", self.name())
return str(self.device.State()) == 'STANDBY'
def connectNotify(self, signal):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.connectNotify, : %s", self.name(), signal)
if signal == 'hardwareObjectName,stateChanged':
self.motorStateChanged(TangoMotorZoomPX2.stateDict[str(
self.device.State())])
elif signal == 'limitsChanged':
self.motorLimitsChanged()
#print "Not implemented yet."PhiTableXAxisPosition
elif signal == 'positionChanged':
#self.motorPositionChanged(self.device.position)
print('MS debug 18.10.2012')
#print self.device
print(self.device.read_attribute("ZoomLevel").value)
self.motorPositionChanged(
self.device.read_attribute(
"ZoomLevel").value) #MS debug 18.10.2012
self.setIsReady(True)
def motorState(self):
return TangoMotorZoomPX2.stateDict[str(self.device.State())]
def motorStateChanged(self, state):
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.motorStateChanged, %s", self.name(), state)
#self.setIsReady(state == 'STANDBY')
self.setIsReady(True)
#print "motorStateChanged", str(state)
self.emit('stateChanged',
(TangoMotorZoomPX2.stateDict[str(self.device.State())], ))
def getState(self):
state = str(self.device.State())
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.getState, %s", self.name(), state)
return TangoMotorZoomPX2.stateDict[str(self.device.State())]
def getLimits(self):
#limits = self.device.getLimits("positiopositionChan.connectSignal("update", self.positionChanged)n")
# MS 18.09.2012 adapted for use without SimpleDevice
position_info = self.device.attribute_query("ZoomLevel")
rlow = 1 # position_info.min_value
rhigh = 10 #position_info.max_value
#logging.getLogger("HWR").info("TangoMotorZoomPX2.getLimits: %.4f %.4f" % limits)
return rlow, rhigh
def motorLimitsChanged(self):
#self.emit('limitsChanged', (self.getLimits(), ))
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.limitsChanged", self.name())
self.emit('limitsChanged', (self.getLimits(), ))
def motorMoveDone(self, channelValue):
#SpecMotorA.motorMoveDone(self, channelValue)
#logging.getLogger("HWR").info("TangoMotorZoomPX2.motorMoveDone")
if str(self.device.State()) == 'STANDBY':
#self.emit('moveDone', (self.specversion, self.specname, ))
self.emit('moveDone', ("EH3", "toto"))
def motorPositionChanged(self, absolutePosition):
self.emit('positionChanged', (absolutePosition, ))
def syncQuestionAnswer(self, specSteps, controllerSteps):
return '0' #NO ('1' means YES)
def getPosition(self):
pos = self.device.read_attribute(
"ZoomLevel").value #self.device.position
#logging.getLogger("HWR").info("%s: TangoMotorZoomPX2.getPosition, pos = %.3f", self.name(), pos)
return pos
def syncMove(self, position):
#print 'about to start moving', self.motorState
t0 = time.time()
prev_position = self.getPosition()
self.device.position = position
print('move started from %s to %s, state is %s' %
(prev_position, position, str(self.device.State())))
while str(self.device.State()) == "RUNNING" or str(
self.device.State()
) == "MOVING": # or str(self.device.State()) == SpecMotor.MOVESTARTED:
#print 'processing events...', self.motorState
qApp.processEvents(100)
print('move done (%s s), state is %s' %
(time.time() - t0, str(self.device.State())))
def moveRelative(self, position):
old_pos = self.device.position
self.device.position = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while str(self.device.State()) == "RUNNING" or str(
self.device.State()) == "MOVING":
qApp.processEvents(100)
def syncMoveRelative(self, position):
old_pos = self.device.position
self.device.position = old_pos + position
#self.moveRelahardwareObjectName,tive(position)
while str(self.device.State()) == "RUNNING" or str(
self.device.State()) == "MOVING":
qApp.processEvents(100)
def getMotorMnemonic(self):
return self.specName
def move(self, absolutePosition):
"""Move the motor to the required position
Arguments:
absolutePosition -- position to move to
"""
if type(absolutePosition) != float and type(absolutePosition) != int:
logging.getLogger("TangoClient").error(
"Cannot move %s: position '%s' is not a number",
self.device.name, absolutePosition)
#self.__changeMotorState(MOVESTARTED)
#c = self.connection.getChannel(self.chanNamePrefix % 'start_one')
logging.getLogger("HWR").info(
"TangoMotorZoomPX2.move to absolute position: %.3f" %
absolutePosition)
self.device.position = absolutePosition
def stop(self):
logging.getLogger("HWR").info("TangoMotorZoomPX2.stop")
self.device.Stop()
def isSpecConnected(self):
logging.getLogger().debug("%s: TangoMotorZoomPX2.isSpecConnected()" %
self.name())
return TruehardwareObjectName,
class Ps_attenuatorPX2(Device):
stateAttenuator = {'ALARM' : 'error','OFF' : 'error', 'RUNNING' : 'moving','MOVING' : 'moving', 'STANDBY' : 'ready', 'UNKNOWN': 'changed', 'EXTRACT': 'outlimits'}
def __init__(self, name):
Device.__init__(self, name)
self.labels = []
self.attno = 0
self.deviceOk = True
self.set_value = None
def init(self):
# cmdToggle = self.getCommandObject('toggle')
# cmdToggle.connectSignal('connected', self.connected)
# cmdToggle.connectSignal('disconnected', self.disconnected)
# Connect to device FP_Parser defined "tangoname" in the xml file
try :
#self.Attenuatordevice = SimpleDevice(self.getProperty("tangoname"), verbose=False)
self.Attenuatordevice = DeviceProxy(self.getProperty("tangoname"))
except :
self.errorDeviceInstance(self.getProperty("tangoname"))
try :
#self.Attenuatordevice = SimpleDevice(self.getProperty("tangoname"), verbose=False)
self.Constdevice = DeviceProxy(self.getProperty("tangoname_const"))
except :
self.errorDeviceInstance(self.getProperty("tangoname_const"))
# Connect to device Primary slit horizontal defined "tangonamePs_h" in the xml file
try :
#self.Ps_hdevice = SimpleDevice(self.getProperty("tangonamePs_h"), verbose=False)
self.Ps_hdevice = DeviceProxy(self.getProperty("tangonamePs_h"))
except :
self.errorDeviceInstance(self.getProperty("tangonamePs_h"))
# Connect to device Primary slit vertical defined "tangonamePs_v" in the xml file
try :
#self.Ps_vdevice = SimpleDevice(self.getProperty("tangonamePs_v"), verbose=False)
self.Ps_vdevice = DeviceProxy(self.getProperty("tangonamePs_v"))
except :
self.errorDeviceInstance(self.getProperty("tangonamePs_v"))
if self.deviceOk:
self.connected()
self.chanAttState = self.getChannelObject('State')
self.chanAttState.connectSignal('update', self.attStateChanged)
self.chanAttFactor = self.getChannelObject('TrueTrans_FP')
self.chanAttFactor.connectSignal('update', self.attFactorChanged)
def getAtteConfig(self):
return
def getAttState(self):
try:
value1= Ps_attenuatorPX2.stateAttenuator[self.Ps_hdevice.State().name]
print('State hslit : ' , Ps_attenuatorPX2.stateAttenuator[self.Ps_hdevice.State().name])
value2= Ps_attenuatorPX2.stateAttenuator[self.Ps_vdevice.State().name]
print('State vslit : ' , Ps_attenuatorPX2.stateAttenuator[self.Ps_vdevice.State().name])
if value1 == 'ready' and value2 == 'ready' :
value = 'ready'
elif value1 == 'error' or value2 == 'error':
value = 'error'
elif value1 == 'moving' or value2 == 'moving' :
value = 'moving'
elif value1 == 'changed' or value == 'changed' :
value = 'changed'
else:
value = None
logging.getLogger().debug("Attenuator state read from the device %s",value)
except:
logging.getLogger("HWR").error('%s getAttState : received value on channel is not a integer value', str(self.name()))
value=None
return value
def attStateChanged(self, channelValue):
value = self.getAttState()
self.emit('attStateChanged', (value, ))
def getAttFactor(self):
try:
if self.Attenuatordevice.TrueTrans_FP <= 100.0 : #self.Attenuatordevice.Trans_FP <= 100.0 :
if self.set_value is not None:
value = self.set_value
else:
value = float(self.Attenuatordevice.TrueTrans_FP) * 1.3587
else :
if self.set_value is not None:
value = self.set_value
else:
value = float(self.Attenuatordevice.I_Trans) * 1.4646
# Mettre une limite superieure car a une certaine ouverture de fentes on ne gagne plus rien en transmission
# Trouver la valeur de transmission par mesure sur QBPM1 doit etre autour de 120%
except:
logging.getLogger("HWR").error('%s getAttFactor : received value on channel is not a float value', str(self.name()))
value=None
return value
def connected(self):
self.setIsReady(True)
def disconnected(self):
self.setIsReady(False)
def attFactorChanged(self, channelValue):
try:
print("Dans attFactorChanged channelValue = %f" %channelValue)
# value = float(channelValue)
value = self.getAttFactor()
except:
logging.getLogger("HWR").error('%s attFactorChanged : received value on channel is not a float value', str(self.name()))
else:
self.emit('attFactorChanged', (value, ))
def attToggleChanged(self, channelValue):
# print "Dans attToggleChanged channelValue = %s" %channelValue
try:
value = int(channelValue)
except:
logging.getLogger("HWR").error('%s attToggleChanged : received value on channel is not a float value', str(self.name()))
else:
self.emit('toggleFilter', (value, ))
def setTransmission(self,value) :
self.set_value = float(value)
try:
if self.Constdevice.FP_Area_FWHM <= 0.1 : # Cas ou il n'y a pas de valeur dans le publisher PASSERELLE/CO/Primary_Slits
logging.getLogger("HWR").error('Primary slits not correctly aligned', str(self.name()))
self.Constdevice.FP_Area_FWHM = 0.5
self.Constdevice.Ratio_FP_Gap = 0.5
truevalue = (2.0 - math.sqrt(4 - 0.04 * value)) / 0.02
print(" truevalue : " , truevalue)
newGapFP_H = math.sqrt((truevalue/100.0) * self.Constdevice.FP_Area_FWHM / self.Constdevice.Ratio_FP_Gap)
print(" Gap FP_H : " , newGapFP_H)
self.Ps_hdevice.gap = newGapFP_H
newGapFP_V = newGapFP_H *self.Constdevice.Ratio_FP_Gap
print(" Gap FP_V : " , newGapFP_V)
self.Ps_vdevice.gap = newGapFP_V
#self.attFactorChanged(channelValue)
except:
logging.getLogger("HWR").error('%s set Transmission : received value on channel is not valid', str(self.name()))
value=None
return value
def toggle(self,value) :
return value
def errorDeviceInstance(self,device) :
db = DeviceProxy("sys/database/dbds1")
logging.getLogger().error("Check Instance of Device server %s" % db.DbGetDeviceInfo(device)[1][3])
self.sDisconnected()
class TangoBeamStop(Device):
beamstopState = {
None: 'unknown',
'UNKNOWN': 'unknown',
'CLOSE': 'closed',
'OPEN': 'opened',
'INSERT': 'opened',
'EXTRACT': 'closed',
'MOVING': 'moving',
'RUNNING': 'moving',
'_': 'automatic',
'FAULT': 'fault',
'DISABLE': 'disabled',
'OFF': 'fault',
'ON': 'unknown'
}
def __init__(self, name):
Device.__init__(self, name)
self.shutterStateValue = 0
self.lastState = None
#self.PSSdevice = None
def init(self):
#stateChan = self.addChannel({ 'type': 'tango', 'name': 'state', 'polling':500 }, "State")
#self.addCommand({'type': 'tango', 'name': 'open' }, "Open")
#self.addCommand({'type': 'tango', 'name': 'close' }, "Close")
self.setIsReady(True)
# Connect to device PSS "tangoname2" in the xml file
#try :
# self.PSSdevice = SimpleDevice(self.getProperty("tangoname2"), verbose=False)
#except :
# # self.errorDeviceInstance(self.getProperty("tangoname2"))
# logging.getLogger("HWR").info("%s: unknown pss device name", self.getProperty("tangoname2"))
try:
self.LightArm = DeviceProxy(self.getProperty("tangoname2"))
except:
logging.getLogger("HWR").info("%s: unknown lightarm device name",
self.getProperty("tangoname2"))
stateChan = self.getChannelObject(
"state"
) # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.stateChanged)
def stateChanged(self, state):
logging.getLogger().debug(
"TangoBeamStop : stateChanged - new state = %s", state)
if state is None or str(state) == "":
return
state = str(state)
if self.lastState != state:
try:
self.emit("shutterStateChanged",
(TangoBeamStop.beamstopState[state], ))
except KeyError:
self.emit("shutterStateChanged", ("unknown", ))
logging.getLogger("HWR").error("%s: unknown shutter state %s",
self.name(), state)
self.lastState = state
def getShutterState(self):
#logging.getLogger().debug("TangoBeamStop : passe dans getShutterState.")
#if self.isPssOk:
return TangoBeamStop.beamstopState[self.lastState]
def isShutterOk(self):
logging.getLogger().debug("TangoBeamStop : isSutterOK")
stateShutter = not self.getShutterState() in (
'unknown', 'moving', 'fault', 'disabled', 'error')
return stateShutter
#def isPssOk(self):
# statePSS = True
# if self.PSSdevice:
# statePSS = self.PSSdevice.pssStatusEH == 1
# if statePSS == False :
# logging.getLogger("HWR").error("%s: experimental hutch search is not finished",self.name())
# return statePSS
def openShutter(self):
logging.getLogger().debug("TangoBeamStop : passe dans openShutter")
# if self.isReady() and self.isShutterOk() and self.isPssOk():
#if self.isShutterOk() and self.isPssOk():
# logging.getLogger().debug("TangoBeamStop : passe dans openShutter 2")
if self.isShutterOk():
if str(self.LightArm.State()) == "INSERT":
self.LightArm.Extract()
time.sleep(2)
cmdOpen = self.getCommandObject("open")
#logging.getLogger().debug("TangoBeamStop : passe dans openShutter 3")
cmdOpen()
#logging.getLogger().debug("TangoBeamStop : passe dans openShutter : shutter open")
#else:
# logging.getLogger("HWR").error("%s: cannot open shutter (%s)", self.name(), self.getShutterState())
def closeShutter(self):
# if self.isReady() and self.isShutterOk():
logging.getLogger().debug("TangoBeamStop : passe dans closeShutter")
if self.isShutterOk():
#if self.LightArm.State == "INSERT":
# self.LightArm.Extract()
# time.sleep(2)
cmdClose = self.getCommandObject("close")
cmdClose()
else:
logging.getLogger("HWR").error("%s: cannot close shutter (%s)",
self.name(), self.getShutterState())
