def __init__(
self,
ID,
VME_crate=None,
link=None,
ch_up=12,
ch_down=13,
ch_left=15,
ch_right=14,
elog=None,
name=None,
):
self.ID = ID
self.name = name
self.diode_x = Motor(ID + ":MOTOR_X1", name="diode_x")
self.diode_y = Motor(ID + ":MOTOR_Y1", name="diode_y")
self.target_pos = Motor(ID + ":MOTOR_PROBE", name="target_pos")
self.target = PVEnumAdjustable(ID + ":PROBE_SP", name="target")
if VME_crate:
self.diode_up = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_up))
self.diode_down = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_down))
self.diode_left = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_left))
self.diode_right = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_right))
if self.name:
self.alias = Alias(name)
self.alias.append(self.diode_x.alias)
self.alias.append(self.diode_y.alias)
self.alias.append(self.target_pos.alias)
self.alias.append(self.target.alias)
def __init__(
self,
adjustables,
foo_get_current_value,
foo_set_target_value_current_value,
reset_current_value_to=False,
append_aliases=False,
name=None,
):
self.name = name
self.alias = Alias(name)
if append_aliases:
for adj in adjustables:
try:
self.alias.append(adj.alias)
except Exception as e:
print(f"could not find alias in {adj}")
print(str(e))
self._adjustables = adjustables
self._foo_set_target_value_current_value = foo_set_target_value_current_value
self._foo_get_current_value = foo_get_current_value
self._reset_current_value_to = reset_current_value_to
if reset_current_value_to:
for adj in self._adjustables:
if not hasattr(adj, "reset_current_value_to"):
raise Exception(
f"No reset_current_value_to method found in {adj}")
def __init__(
self,
pvname,
name=None,
reduction_client_address="http://sf-daqsync-02:12002/",
delay_stages={
"spect_tt": "SLAAR21-LMOT-M553:MOT",
"retroreflector": "SLAAR21-LMOT-M561:MOT"
}):
self.pvname = pvname
self.name = name
self.alias = Alias(name)
append_object_to_object(self,
Motor,
pvname + ":MOTOR_X1",
name="x_target")
append_object_to_object(self,
Motor,
pvname + ":MOTOR_Y1",
name="y_target")
if delay_stages:
for key, pv in delay_stages.items():
tname = "delay_" + key + "_stg"
append_object_to_object(self, Motor, pv, name=tname)
append_object_to_object(self,
DelayTime,
self.__dict__[tname],
name="delay_" + key)
#self.delay = Motor(self.ID + "-M424:MOT")
#self.delayTime = DelayStage(self.delay)
self.data_reduction_client = PsenProcessingClient(
address=reduction_client_address)
def __init__(self, ID, E_min=1500, sleeptime=1, name=None, limits=[-52, 2], pulse_picker=None):
self.ID = ID
self._pv_status_str = PV(ID + ":MOT2TRANS.VALD")
self._pv_status_int = PV(ID + ":IDX_RB")
self.E_min = E_min
self._sleeptime = sleeptime
self.name = name
self.alias = Alias(name)
self.pulse_picker = pulse_picker
self.motors = [Motor(f"{self.ID}:MOTOR_{n+1}", name=f"motor{n+1}") for n in range(6)]
for n, mot in enumerate(self.motors):
self.__dict__[f"motor_{n+1}"] = mot
self.alias.append(mot.alias)
if limits:
mot.set_epics_limits(*limits)
def __init__(self,
name=None,
reduction_client_address="http://sf-daqsync-02:12003/",
delay_stages={"spatial_tt": "SLAAR21-LMOT-M522:MOTOR_1"},
pipeline_id="SARES20-CAMS142-M4_psen_db1"):
self.name = name
self.alias = Alias(name)
#append_object_to_object(self,Motor,pvname+":MOTOR_X1",name='x_target')
#append_object_to_object(self,Motor,pvname+":MOTOR_Y1",name='y_target')
if delay_stages:
for key, pv in delay_stages.items():
tname = "delay_" + key + "_stg"
append_object_to_object(self, Motor, pv, name=tname)
append_object_to_object(self,
DelayTime,
self.__dict__[tname],
name="delay_" + key)
#self.delay = Motor(self.ID + "-M424:MOT")
#self.delayTime = DelayStage(self.delay)
#self.data_reduction_client = PsenProcessingClient(address=reduction_client_address)
self._camera_server_client = PipelineClient()
self._camera_server_pipeline_id = pipeline_id
def __init__(self, pvname, name=None, elog=None):
self.name = name
self.ID = pvname
self.alias = Alias(name)
append_object_to_object(self, Motor, pvname + ":MOT_1", name="right")
append_object_to_object(self, Motor, pvname + ":MOT_2", name="left")
append_object_to_object(self, Motor, pvname + ":MOT_4", name="down")
append_object_to_object(self, Motor, pvname + ":MOT_3", name="up")
def getgap(xn, xp):
return xp - xn
def getpos(xn, xp):
return (xn + xp) / 2
def setwidth(x):
return tuple(
[tx + self.hpos.get_current_value() for tx in [-x / 2, x / 2]])
def setheight(x):
return tuple(
[tx + self.vpos.get_current_value() for tx in [-x / 2, x / 2]])
def sethpos(x):
return tuple(
[tx + self.hgap.get_current_value() for tx in [-x / 2, x / 2]])
def setvpos(x):
return tuple(
[tx + self.vgap.get_current_value() for tx in [-x / 2, x / 2]])
append_object_to_object(
self,
AdjustableVirtual,
[self.right, self.left],
getgap,
setwidth,
reset_current_value_to=True,
name="hgap",
)
append_object_to_object(
self,
AdjustableVirtual,
[self.down, self.up],
getgap,
setheight,
reset_current_value_to=True,
name="vgap",
)
append_object_to_object(
self,
AdjustableVirtual,
[self.right, self.left],
getpos,
sethpos,
reset_current_value_to=True,
name="hpos",
)
append_object_to_object(
self,
AdjustableVirtual,
[self.down, self.up],
getpos,
setvpos,
reset_current_value_to=True,
name="vpos",
)
def __init__(self, pvname, name=None, elog=None):
self.name = name
self.ID = pvname
self.alias = Alias(name)
append_object_to_object(self, Motor, pvname + ":MOTOR_X", name="hpos")
append_object_to_object(self, Motor, pvname + ":MOTOR_Y", name="vpos")
append_object_to_object(self, Motor, pvname + ":MOTOR_W", name="hgap")
append_object_to_object(self, Motor, pvname + ":MOTOR_H", name="vgap")
def getblade(pos, gap, direction=1):
return pos + direction * gap / 2
def setblade(bde, pos, gap, direction=1):
delta = bde - getblade(pos, gap, direction=direction)
ngap = gap + direction * delta
npos = pos + direction * delta / 2
return npos, ngap
def getpos(xn, xp):
return (xn + xp) / 2
def setwidth(x):
return tuple(
[tx + self.hpos.get_current_value() for tx in [-x / 2, x / 2]])
def setheight(x):
return tuple(
[tx + self.vpos.get_current_value() for tx in [-x / 2, x / 2]])
def sethpos(x):
return tuple(
[tx + self.hgap.get_current_value() for tx in [-x / 2, x / 2]])
def setvpos(x):
return tuple(
[tx + self.vgap.get_current_value() for tw in [-x / 2, x / 2]])
append_object_to_object(self,
AdjustableVirtual, [self.vpos, self.vgap],
partial(getblade, direction=1),
partial(setblade, direction=1),
reset_current_value_to=True,
name="up")
append_object_to_object(self,
AdjustableVirtual, [self.vpos, self.vgap],
partial(getblade, direction=-1),
partial(setblade, direction=-1),
reset_current_value_to=True,
name="down")
append_object_to_object(self,
AdjustableVirtual, [self.hpos, self.hgap],
partial(getblade, direction=1),
partial(setblade, direction=1),
reset_current_value_to=True,
name="left")
append_object_to_object(self,
AdjustableVirtual, [self.hpos, self.hgap],
partial(getblade, direction=-1),
partial(setblade, direction=-1),
reset_current_value_to=True,
name="right")
class SolidTargetDetectorPBPS:
def __init__(
self,
ID,
VME_crate=None,
link=None,
ch_up=12,
ch_down=13,
ch_left=15,
ch_right=14,
elog=None,
name=None,
):
self.ID = ID
self.name = name
self.diode_x = Motor(ID + ":MOTOR_X1", name="diode_x")
self.diode_y = Motor(ID + ":MOTOR_Y1", name="diode_y")
self.target_pos = Motor(ID + ":MOTOR_PROBE", name="target_pos")
self.target = PVEnumAdjustable(ID + ":PROBE_SP", name="target")
if VME_crate:
self.diode_up = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_up))
self.diode_down = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_down))
self.diode_left = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_left))
self.diode_right = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_right))
if self.name:
self.alias = Alias(name)
self.alias.append(self.diode_x.alias)
self.alias.append(self.diode_y.alias)
self.alias.append(self.target_pos.alias)
self.alias.append(self.target.alias)
def __repr__(self):
s = f"**Intensity monitor {self.name}**\n\n"
s += f"Target in: {self.target.get_current_value().name}\n\n"
try:
sd = "**Biasd voltage**\n"
sd += " - Diode up: %.4f\n" % (sdelf.diode_up.get_biasd())
sd += " - Diode down: %.4f\n" % (sdelf.diode_down.get_biasd())
sd += " - Diode left: %.4f\n" % (sdelf.diode_left.get_biasd())
sd += " - Diode right: %.4f\n" % (sdelf.diode_right.get_biasd())
sd += "\n"
sd += "**Gain**\n"
sd += " - Diode up: %i\n" % (sdelf.diode_up.gain.get())
sd += " - Diode down: %i\n" % (sdelf.diode_down.gain.get())
sd += " - Diode left: %i\n" % (sdelf.diode_left.gain.get())
sd += " - Diode right: %i\n" % (sdelf.diode_right.gain.get())
s += sd
except:
pass
return s
def set_gains(self, value):
try:
self.diode_up.gain.set(value)
self.diode_down.gain.set(value)
self.diode_left.gain.set(value)
self.diode_right.gain.set(value)
except:
print("No diodes configured, can not change any gain!")
def get_available_gains(self):
try:
nu = self.diode_up.gain.names
nd = self.diode_down.gain.names
nl = self.diode_left.gain.names
nr = self.diode_right.gain.names
assert nu == nd == nl == nr, "NB: the gain options of the four diodes are not equal!!!"
return nu
except:
print("No diodes configured, can not change any gain!")
def get_gains(self):
try:
gains = dict()
gains["up"] = (self.diode_up.gain.get_name(),
self.diode_up.gain.get())
gains["down"] = (
self.diode_down.gain.get_name(),
self.diode_down.gain.get(),
)
gains["left"] = (
self.diode_left.gain.get_name(),
self.diode_left.gain.get(),
)
gains["right"] = (
self.diode_right.gain.get_name(),
self.diode_right.gain.get(),
)
return gains
except:
print("No diodes configured, can not change any gain!")
def __init__(
self,
pvname,
VME_crate=None,
link=None,
channels={},
ch_up=12,
ch_down=13,
ch_left=15,
ch_right=14,
elog=None,
name=None,
calc=None,
calc_calib={},
):
self.name = name
self.pvname = pvname
self.alias = Alias(name)
append_object_to_object(self,
Motor,
pvname + ":MOTOR_X1",
name="x_diodes")
append_object_to_object(self,
Motor,
pvname + ":MOTOR_Y1",
name="y_diodes")
append_object_to_object(self,
Motor,
pvname + ":MOTOR_PROBE",
name="target_y")
append_object_to_object(self,
PVEnumAdjustable,
pvname + ":PROBE_SP",
name="target")
if VME_crate:
self.diode_up = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_up))
self.diode_down = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_down))
self.diode_left = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_left))
self.diode_right = FeDigitizer("%s:Lnk%dCh%d" %
(VME_crate, link, ch_right))
if channels:
append_object_to_object(self,
PvDataStream,
channels["up"],
name="signal_up")
append_object_to_object(self,
PvDataStream,
channels["down"],
name="signal_down")
append_object_to_object(self,
PvDataStream,
channels["left"],
name="signal_left")
append_object_to_object(self,
PvDataStream,
channels["right"],
name="signal_right")
if calc:
append_object_to_object(self,
PvDataStream,
calc["itot"],
name="intensity")
append_object_to_object(self,
PvDataStream,
calc["xpos"],
name="xpos")
append_object_to_object(self,
PvDataStream,
calc["ypos"],
name="ypos")
class AdjustableVirtual(SpecConvenience):
def __init__(
self,
adjustables,
foo_get_current_value,
foo_set_target_value_current_value,
reset_current_value_to=False,
append_aliases=False,
name=None,
):
self.name = name
self.alias = Alias(name)
if append_aliases:
for adj in adjustables:
try:
self.alias.append(adj.alias)
except Exception as e:
print(f"could not find alias in {adj}")
print(str(e))
self._adjustables = adjustables
self._foo_set_target_value_current_value = foo_set_target_value_current_value
self._foo_get_current_value = foo_get_current_value
self._reset_current_value_to = reset_current_value_to
if reset_current_value_to:
for adj in self._adjustables:
if not hasattr(adj, "reset_current_value_to"):
raise Exception(
f"No reset_current_value_to method found in {adj}")
def set_target_value(self, value, hold=False):
vals = self._foo_set_target_value_current_value(value)
if not hasattr(vals, "__iter__"):
vals = (vals, )
def changer():
self._active_changers = [
adj.set_target_value(val, hold=False)
for val, adj in zip(vals, self._adjustables)
]
for tc in self._active_changers:
tc.wait()
def stopper():
for tc in self._active_changers:
tc.stop()
self._currentChange = Task(changer, hold=hold, stopper=stopper)
return self._currentChange
def get_current_value(self):
return self._foo_get_current_value(
*[adj.get_current_value() for adj in self._adjustables])
def set_current_value(self, value):
if not self._set_current_value:
raise NotImplementedError(
"There is no value setting implemented for this virtual adjuster!"
)
else:
vals = self._foo_set_target_value_current_value(value)
for adj, val in zip(self._adjustables, vals):
adj.set_current_value(val)
#TODO: below from DefaultRepresentation
def _get_name(self):
if self.alias:
return self.alias.get_full_name()
elif self.name:
return self.name
else:
return self.ID
def __repr__(self):
s = datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S") + ": "
s += f"{colorama.Style.BRIGHT}{self._get_name()}{colorama.Style.RESET_ALL} at {colorama.Style.BRIGHT}{self.get_current_value():g}{colorama.Style.RESET_ALL}"
return s
class AttenuatorAramis:
def __init__(self, ID, E_min=1500, sleeptime=1, name=None, limits=[-52, 2], pulse_picker=None):
self.ID = ID
self._pv_status_str = PV(ID + ":MOT2TRANS.VALD")
self._pv_status_int = PV(ID + ":IDX_RB")
self.E_min = E_min
self._sleeptime = sleeptime
self.name = name
self.alias = Alias(name)
self.pulse_picker = pulse_picker
self.motors = [Motor(f"{self.ID}:MOTOR_{n+1}", name=f"motor{n+1}") for n in range(6)]
for n, mot in enumerate(self.motors):
self.__dict__[f"motor_{n+1}"] = mot
self.alias.append(mot.alias)
if limits:
mot.set_epics_limits(*limits)
def updateE(self, energy=None):
while not energy:
energy = PV("SARUN03-UIND030:FELPHOTENE").value
energy = energy * 1000
if energy < self.E_min:
energy = None
print(f"Machine photon energy is below {self.E_min} - waiting for the machine to recover")
sleep(self._sleeptime)
PV(self.ID + ":ENERGY").put(energy)
print("Set energy to %s eV" % energy)
def set_transmission(self, value, energy=None):
self.updateE(energy)
PV(self.ID + ":3RD_HARM_SP").put(0)
PV(self.ID + ":TRANS_SP").put(value)
def set_transmission_third_harmonic(self, value, energy=None):
self.updateE(energy)
PV(self.ID + ":3RD_HARM_SP").put(1)
PV(self.ID + ":TRANS_SP").put(value)
def setE(self):
pass
def get_transmission(self, verbose=True):
tFun = PV(self.ID + ":TRANS_RB").value
tTHG = PV(self.ID + ":TRANS3EDHARM_RB").value
if verbose:
print("Transmission Fundamental: %s THG: %s" % (tFun, tTHG))
return tFun, tTHG
def get_current_value(self, *args, **kwargs):
return self.get_transmission(*args, verbose=False, **kwargs)[0]
def set_target_value(self, value, sleeptime=10, hold=False):
def changer():
self.set_transmission(value)
sleep(sleeptime)
if self.pulse_picker:
self.pulse_picker.open()
return Task(changer, hold=hold)
def get_status(self):
s_str = self._pv_status_str.get(as_string=True)
s_int = self._pv_status_int.get()
return s_str, s_int
def __repr__(self):
t = self.get_transmission()
s = "1st harm. transmission = %g\n" % t[0]
s += "3rd harm. transmission = %g\n" % t[1]
s += "Targets in beam:\n"
s += "%s" % self.get_status()[0]
return s
def __call__(self, *args, **kwargs):
self.set_transmission(*args, **kwargs)
def __init__(self, ID, name=None):
self.ID = ID
self._pv = PV(ID)
self.name = name
self.alias = Alias(self.name, channel=self.ID, channeltype="CA")