def get_bpms_xy(self, bpms):
X = [0.0]*len(bpms)#np.zeros(len(correctors))
Y = [0.0]*len(bpms)
for i in range(len(bpms)):
mag_channel = 'TTF2.DIAG/ORBIT/' + bpms[i]# + '/PS'
X[i] = pydoocs.read(mag_channel + "/X.FLASH1.PULSE.MEAN")['data']*0.001 # mm -> m
Y[i] = pydoocs.read(mag_channel + "/Y.FLASH1.PULSE.MEAN")['data']*0.001 # mm -> m
return X, Y
def get_sase_pos(self):
x1 = pydoocs.read('TTF2.FEL/GMDPOSMON/TUNNEL/IX.POS')['data']
y1 = pydoocs.read('TTF2.FEL/GMDPOSMON/TUNNEL/IY.POS')['data']
x2 = pydoocs.read('TTF2.FEL/GMDPOSMON/BDA/IX.POS')['data']
y2 = pydoocs.read('TTF2.FEL/GMDPOSMON/BDA/IY.POS')['data']
return [ (x1,y1), (x2,y2) ]
def get_sase_pos(self):
x1 = pydoocs.read('TTF2.FEL/GMDPOSMON/TUNNEL/IX.POS')['data']
y1 = pydoocs.read('TTF2.FEL/GMDPOSMON/TUNNEL/IY.POS')['data']
x2 = pydoocs.read('TTF2.FEL/GMDPOSMON/BDA/IX.POS')['data']
y2 = pydoocs.read('TTF2.FEL/GMDPOSMON/BDA/IY.POS')['data']
return [(x1, y1), (x2, y2)]
def get_bpms_xy(self, bpms):
X = [0.0] * len(bpms) #np.zeros(len(correctors))
Y = [0.0] * len(bpms)
for i in range(len(bpms)):
ch = 'XFEL.DIAG/ORBIT/' + bpms[i]
#print(ch)
X[i] = pydoocs.read(ch + "/X.SA1")['data'] * 0.001 # mm -> m
Y[i] = pydoocs.read(ch + "/Y.SA1")['data'] * 0.001 # mm -> m
return X, Y
def get_bpms_xy(self, bpms):
X = [0.0]*len(bpms)#np.zeros(len(correctors))
Y = [0.0]*len(bpms)
for i in range(len(bpms)):
ch = 'XFEL.DIAG/ORBIT/' + bpms[i]
#print(ch)
X[i] = pydoocs.read(ch + "/X.SA1")['data']*0.001 # mm -> m
Y[i] = pydoocs.read(ch + "/Y.SA1")['data']*0.001 # mm -> m
return X, Y
def get_bpms_xy(self, bpms):
X = [0.0] * len(bpms) #np.zeros(len(correctors))
Y = [0.0] * len(bpms)
for i in range(len(bpms)):
mag_channel = 'TTF2.DIAG/ORBIT/' + bpms[i] # + '/PS'
X[i] = pydoocs.read(mag_channel + "/X.FLASH1.PULSE.MEAN"
)['data'] * 0.001 # mm -> m
Y[i] = pydoocs.read(mag_channel + "/Y.FLASH1.PULSE.MEAN"
)['data'] * 0.001 # mm -> m
return X, Y
def get_bpms_xy(self, bpms):
"""
Method for getting bmps data
:param bpms: list of string. BPMs names
:return: X, Y - two arrays in [m]
"""
X = [0.0] * len(bpms)
Y = [0.0] * len(bpms)
for i in range(len(bpms)):
ch = 'XFEL.DIAG/ORBIT/' + bpms[i]
X[i] = pydoocs.read(ch + "/X.SA1")['data'] * 0.001 # mm -> m
Y[i] = pydoocs.read(ch + "/Y.SA1")['data'] * 0.001 # mm -> m
return X, Y
def get_sase(self, detector='gmd_default'):
#print(detector)
if detector == 'mcp':
# incorrect
return pydoocs.read('TTF2.DIAG/MCP.HV/MCP.HV1/HV_CURRENT')['data']
#return np.abs( np.mean(h) )
if detector == 'gmd_fl1_slow':
return pydoocs.read('TTF2.FEL/BKR.FLASH.STATE/BKR.FLASH.STATE/SLOW.INTENSITY' )['data']
if detector == "bkr":
# default 'BKR' gmd
h = np.array(pydoocs.read('TTF2.FEL/BKR.FLASH.STATE/BKR.FLASH.STATE/ENERGY.CLIP.SPECT')['data'])
val = np.mean(np.array([x[1] for x in h]))
return val
return pydoocs.read("TTF2.FEL/PHFLUX/TUNNEL/ENPULSEIC")['data']
def get_bpms_xy(self, bpms):
"""
Method for getting bmps data
:param bpms: list of string. BPMs names
:return: X, Y - two arrays in [m]
"""
X = [0.0]*len(bpms)
Y = [0.0]*len(bpms)
for i in range(len(bpms)):
ch = 'XFEL.DIAG/ORBIT/' + bpms[i]
X[i] = pydoocs.read(ch + "/X.SA1")['data']*0.001 # mm -> m
Y[i] = pydoocs.read(ch + "/Y.SA1")['data']*0.001 # mm -> m
return X, Y
def get_alarms(self):
alarm_vals = np.zeros(len(self.blm_names))
for i in range(len(self.blm_names)):
blm_channel = 'XFEL.DIAG/BLM/'+self.blm_names[i]+'/SIGNAL.SA1'
blm_alarm_ch = 'XFEL.DIAG/BLM/'+self.blm_names[i] + '/SINGLE_ALARM_THRESHOLD'
if (self.debug): print('reading alarm channel', blm_alarm_ch)
#print('reading alarm channel', blm_alarm_ch)
alarm_val = pydoocs.read(blm_alarm_ch)['data']
if (self.debug): print ('alarm:', alarm_val)
#print("blm channel: ", blm_channel)
val = pydoocs.read(blm_channel)['data']
#h = np.array([x[1] for x in sample])
#alarm_vals[i] = np.max( np.abs(h) ) / alarm_val
alarm_vals[i] = val/alarm_val
return alarm_vals
def get_alarms(self):
alarm_vals = np.zeros(len(self.blm_names))
for i in range(len(self.blm_names)):
blm_channel = 'XFEL.DIAG/BLM/' + self.blm_names[i] + '/SIGNAL.SA1'
blm_alarm_ch = 'XFEL.DIAG/BLM/' + self.blm_names[
i] + '/SINGLE_ALARM_THRESHOLD'
if (self.debug): print('reading alarm channel', blm_alarm_ch)
#print('reading alarm channel', blm_alarm_ch)
alarm_val = pydoocs.read(blm_alarm_ch)['data']
if (self.debug): print('alarm:', alarm_val)
#print("blm channel: ", blm_channel)
val = pydoocs.read(blm_channel)['data']
#h = np.array([x[1] for x in sample])
#alarm_vals[i] = np.max( np.abs(h) ) / alarm_val
alarm_vals[i] = val / alarm_val
return alarm_vals
def get_alarms(self):
"""
Method for getting BLMs level. BLMs are predefined
:return: arrays of the BLMs level
"""
alarm_vals = np.zeros(len(self.blm_names))
for i in range(len(self.blm_names)):
blm_channel = 'XFEL.DIAG/BLM/'+self.blm_names[i]+'/SIGNAL.SA1'
blm_alarm_ch = 'XFEL.DIAG/BLM/'+self.blm_names[i] + '/SINGLE_ALARM_THRESHOLD'
if (self.debug): print('reading alarm channel', blm_alarm_ch)
alarm_val = pydoocs.read(blm_alarm_ch)['data']
if (self.debug): print ('alarm:', alarm_val)
val = pydoocs.read(blm_channel)['data']
alarm_vals[i] = val/alarm_val
return alarm_vals
def to_hdf(self, filename: str, key_list: list, number_of_trains: int) -> None:
self.assert_to_hdf(filename, key_list, number_of_trains)
pydoocs_dict = pydoocs.read(self.doocs_addr)
self.assert_pydoocs_dict(key_list)
number_of_passed_train = 0
dset = {}
with h5py.File(filename, "w") as f:
for key in key_list:
if type(pydoocs_dict[key]) in [int, float]:
dset[key] = f.create_dataset(key, (number_of_trains,), dtype=np.dtype(type(pydoocs_dict[key])))
if isinstance(pydoocs_dict[key], np.ndarray):
dset[key] = f.create_dataset(key, (
number_of_trains, pydoocs_dict[key].shape[0], pydoocs_dict[key].shape[1]))
if isinstance(pydoocs_dict[key], str):
key_list.remove(key)
f.attrs[key] = pydoocs_dict[key]
print('The following key is a string and therefore appended as file.attribute: {}'.format(key))
for channel in self.trains(number_of_trains):
for key in key_list:
try:
dset[key][number_of_passed_train] = channel[key]
except:
pass
number_of_passed_train += 1
print('Done - Writing {} trains to HDF5.'.format(number_of_trains))
def get_alarms(self):
alarm_vals = np.zeros(len(self.blm_names))
for i in range(len(self.blm_names)):
blm_channel = 'TTF2.DIAG/BLM/'+self.blm_names[i]+'/CH00.TD'
blm_alarm_ch = ('TTF2.DIAG/BLM/'+self.blm_names[i]).replace('BLM', 'BLM.ALARM') + '/THRFHI'
if (self.debug): print('reading alarm channel', blm_alarm_ch)
alarm_val = pydoocs.read(blm_alarm_ch)['data'] * 1.25e-3 # alarm thr. in Volts
if (self.debug): print ('alarm:', alarm_val)
sample = pydoocs.read(blm_channel)['data']
h = np.array([x[1] for x in sample])
alarm_vals[i] = np.max( np.abs(h) ) / alarm_val
#alarm_vals = np.append(alarm_vals, self.get_alarm_ACC39() )
#print(alarm_vals)
return alarm_vals
def get_alarms(self):
"""
Method for getting BLMs level. BLMs are predefined
:return: arrays of the BLMs level
"""
alarm_vals = np.zeros(len(self.blm_names))
for i in range(len(self.blm_names)):
blm_channel = 'XFEL.DIAG/BLM/' + self.blm_names[i] + '/SIGNAL.SA1'
blm_alarm_ch = 'XFEL.DIAG/BLM/' + self.blm_names[
i] + '/SINGLE_ALARM_THRESHOLD'
if (self.debug): print('reading alarm channel', blm_alarm_ch)
alarm_val = pydoocs.read(blm_alarm_ch)['data']
if (self.debug): print('alarm:', alarm_val)
val = pydoocs.read(blm_channel)['data']
alarm_vals[i] = val / alarm_val
return alarm_vals
def get_value(self, channel):
"""
Getter function for XFEL.
:param channel: (str) String of the devices name used in doocs
:return: Data from pydoocs.read(), variable data type depending on channel
"""
val = pydoocs.read(channel)
return val["data"]
def get_alarms(self):
alarm_vals = np.zeros(len(self.blm_names))
for i in range(len(self.blm_names)):
blm_channel = 'TTF2.DIAG/BLM/' + self.blm_names[i] + '/CH00.TD'
blm_alarm_ch = ('TTF2.DIAG/BLM/' + self.blm_names[i]).replace(
'BLM', 'BLM.ALARM') + '/THRFHI'
if (self.debug): print('reading alarm channel', blm_alarm_ch)
alarm_val = pydoocs.read(
blm_alarm_ch)['data'] * 1.25e-3 # alarm thr. in Volts
if (self.debug): print('alarm:', alarm_val)
sample = pydoocs.read(blm_channel)['data']
h = np.array([x[1] for x in sample])
alarm_vals[i] = np.max(np.abs(h)) / alarm_val
#alarm_vals = np.append(alarm_vals, self.get_alarm_ACC39() )
#print(alarm_vals)
return alarm_vals
def get_value(self, channel):
"""
Getter function for XFEL.
:param channel: (str) String of the devices name used in doocs
:return: Data from pydoocs.read(), variable data type depending on channel
"""
val = pydoocs.read(channel)
return val["data"]
def get_sase(self, detector='gmd_default'):
#print(detector)
if detector == 'mcp':
# incorrect
return pydoocs.read('TTF2.DIAG/MCP.HV/MCP.HV1/HV_CURRENT')['data']
#return np.abs( np.mean(h) )
if detector == 'gmd_fl1_slow':
return pydoocs.read(
'TTF2.FEL/BKR.FLASH.STATE/BKR.FLASH.STATE/SLOW.INTENSITY'
)['data']
if detector == "bkr":
# default 'BKR' gmd
h = np.array(
pydoocs.read(
'TTF2.FEL/BKR.FLASH.STATE/BKR.FLASH.STATE/ENERGY.CLIP.SPECT'
)['data'])
val = np.mean(np.array([x[1] for x in h]))
return val
return pydoocs.read("TTF2.FEL/PHFLUX/TUNNEL/ENPULSEIC")['data']
def get_value(self, device_name):
#ch = 'XFEL.MAGNETS/MAGNET.ML/' + device_name + '/CURRENT.RBV'
ch = 'XFEL.MAGNETS/MAGNET.ML/' + device_name + '/KICK_MRAD.SP'
#print("getting value = ", ch)
#self.mutex.acquire()
val = pydoocs.read(ch)
#print(val)
#['data']
#self.mutex.release()
return val["data"]
def get_spectrum(self, f=None, detector='tunnel_default'):
f_min = 13.0 # spectrum window (nm). TODO: replace with readout
f_max = 14.0
spec = np.array(pydoocs.read('TTF2.EXP/PBD.PHOTONWL.ML/WAVE_LENGTH/VAL.TD')['data'])
if f == None:
f = np.linspace(f_min, f_max, len(spec))
return f, spec
def get_value(self, device_name):
#ch = 'XFEL.MAGNETS/MAGNET.ML/' + device_name + '/CURRENT.RBV'
ch = 'XFEL.MAGNETS/MAGNET.ML/' + device_name + '/KICK_MRAD.SP'
#print("getting value = ", ch)
#self.mutex.acquire()
val = pydoocs.read(ch)
#print(val)
#['data']
#self.mutex.release()
return val["data"]
def get_value(self, channel):
"""
Getter function for XFEL.
:param channel: (str) String of the devices name used in doocs
:return: Data from pydoocs.read(), variable data type depending on channel
"""
logger.debug(" get_value: channel" + channel)
val = pydoocs.read(channel)
#print(channel, " TIMESTAMP:", val["timestamp"])
return val["data"]
def get_value(self, channel):
"""
Getter function for XFEL.
:param channel: (str) String of the devices name used in doocs
:return: Data from pydoocs.read(), variable data type depending on channel
"""
try:
val = pydoocs.read(channel)
except pydoocs.DoocsException:
val={'data':float('nan')}
return val["data"]
def get_spectrum(self, f=None, detector='tunnel_default'):
f_min = 13.0 # spectrum window (nm). TODO: replace with readout
f_max = 14.0
spec = np.array(
pydoocs.read('TTF2.EXP/PBD.PHOTONWL.ML/WAVE_LENGTH/VAL.TD')
['data'])
if f == None:
f = np.linspace(f_min, f_max, len(spec))
return f, spec
def write_doocs(self):
self.doocs_permit = True
try:
pydoocs.write("XFEL.UTIL/DYNPROP/HIREX.SA2/PIXEL_CALIBRATION",
self.pixel_calibration_mean)
self.pixel_doocs = pydoocs.read(
"XFEL.UTIL/DYNPROP/HIREX.SA2/PIXEL_CALIBRATION")
pydoocs.write("XFEL.UTIL/DYNPROP/HIREX.SA2/CENTRAL_ENERGY",
self.dE_mean)
self.central_doocs = pydoocs.read(
"XFEL.UTIL/DYNPROP/HIREX.SA2/CENTRAL_ENERGY")
pydoocs.write("XFEL.UTIL/DYNPROP/HIREX.SA2/FILENAME",
self.file_name)
self.filename_doocs = pydoocs.read(
"XFEL.UTIL/DYNPROP/HIREX.SA2/FILENAME")
pydoocs.write("XFEL.UTIL/DYNPROP/HIREX.SA2/TIMESTAMP",
self.date_time_obj)
self.timestamp_doocs = pydoocs.read(
"XFEL.UTIL/DYNPROP/HIREX.SA2/TIMESTAMP")
self.ui.output.setText(self.ui.output.text() +
"DOOCS PIXEL_CALIBRATION value: " +
str(self.pixel_doocs['data']) + '\n')
self.ui.output.setText(self.ui.output.text() +
"DOOCS CENTRAL_ENERGY value: " +
str(self.central_doocs['data']) + '\n')
self.ui.output.setText(self.ui.output.text() +
"DOOCS FILENAME value: " +
str(self.filename_doocs['data']) + '\n')
self.ui.output.setText(self.ui.output.text() +
"DOOCS TIMESTAMP value: " +
str(self.timestamp_doocs['data']) + '\n')
except:
self.doocs_permit = False
if not self.doocs_permit:
self.ui.output.setText(self.ui.output.text() +
"Control: no permission to write to DOOCS" +
'\n')
def trains(self, number_of_trains: int) -> dict:
""" Retruns *number_of_trains* unique trains as generator
*number_of_trains* = -1 will loop indefinitely"""
number_of_passed_train = 0
while (number_of_passed_train < number_of_trains) or number_of_trains == -1:
pydoocs_dict = pydoocs.read(self.doocs_addr)
self.assert_pydoocs_dict()
current_id = pydoocs_dict['macropulse']
assert current_id != 0, '{} returns trainID: 0'.format(self.doocs_addr)
if self.train_id != current_id:
self.train_id = current_id
yield pydoocs_dict
number_of_passed_train += 1
else:
time.sleep(0.01)
def load_from_doocs(self):
try:
self.pixel_doocs = pydoocs.read(
"XFEL.UTIL/DYNPROP/HIREX.SA2/PIXEL_CALIBRATION")
self.central_doocs = pydoocs.read(
"XFEL.UTIL/DYNPROP/HIREX.SA2/CENTRAL_ENERGY")
if self.central_doocs['data'] > 1999 and self.central_doocs[
'data'] <= 20000:
self.parent.ui.sb_E0.setValue(self.central_doocs['data'])
else:
self.ui.output.setText(
self.ui.output.text() +
"Cannot set the Eo parameter outside the predefined range [2k eV, 20 keV]"
+ '\n')
if self.pixel_doocs['data'] > 0 and self.pixel_doocs['data'] <= 1:
self.parent.ui.sb_ev_px.setValue(self.pixel_doocs['data'])
else:
self.ui.output.setText(
self.ui.output.text() +
"Cannot set the ev/px parameter outside the range [0, 1]" +
'\n')
except:
self.ui.output.setText(self.ui.output.text() +
"No permission to read from DOOCS" + '\n')
def get_doocs_history(self, start_time: str, stop_time: str) -> Tuple[np.ndarray, np.ndarray]:
"""
Returns a np.array of datetime objects and a np.array
of DOOCS values ['data'] from the DOOOCS history for
a given time interval
"""
self.assert_time_string([start_time, stop_time])
self.start_time = self.time_to_timestamp(start_time)
self.stop_time = self.time_to_timestamp(stop_time)
pydoocs_dict = pydoocs.read(self.doocs_addr, parameters=[self.start_time, self.stop_time, 256, 0])
self.assert_pydoocs_dict(pydoocs_dict)
timestamps = np.array(pydoocs_dict["data"])[:, 0]
values = np.array(pydoocs_dict["data"])[:, 1]
times = np.array([datetime.fromtimestamp(timestamp) for timestamp in timestamps])
self.assert_return_values(times, values)
return times, values
def read_doocs_values(self, addresses, doocs_property):
results = []
for address in addresses:
address_single = address + doocs_property
#print(address_single)
try:
results += [pyd.read(address_single)['data']]
except:
message = "Following address does not get a doocs value"
message += address_single
if self.textbox != None:
self.textbox.setTextColor(QtGui.QColor(255, 0, 0))
self.textbox.append(message)
self.textbox.setTextColor(QtGui.QColor(0, 0, 0))
else:
print(message)
return results
def get_value(self, device_name):
#print(device_name, device_name.find("ACC"))
if device_name.find("ACC") == 0:
ch = 'FLASH.RF/LLRF.CONTROLLER/CTRL.' + device_name
elif device_name.find("knob") >= 0:
pass
#return get_knob_value(device_name)
elif device_name.find("SUMVOLTAGE") >= 0:
ch = 'FLASH.RF/LLRF.SUMVOLTAGE_CTRL/ACC139/' + device_name + '.SP.FLASH1'
else:
ch = 'TTF2.MAGNETS/STEERER/' + device_name + '/PS.RBV'
#print("getting value = ", ch)
#self.mutex.acquire()
try:
val = pydoocs.read(ch)['data']
return val
except:
print("Error in pydoocs.read(): ch = ", ch)
def get_value(self, device_name):
#print(device_name, device_name.find("ACC"))
if device_name.find("ACC")==0:
ch = 'FLASH.RF/LLRF.CONTROLLER/CTRL.' + device_name
elif device_name.find("knob")>=0:
pass
#return get_knob_value(device_name)
elif device_name.find("SUMVOLTAGE")>=0:
ch = 'FLASH.RF/LLRF.SUMVOLTAGE_CTRL/ACC139/' + device_name + '.SP.FLASH1'
else:
ch = 'TTF2.MAGNETS/STEERER/' + device_name + '/PS.RBV'
#print("getting value = ", ch)
#self.mutex.acquire()
try:
val = pydoocs.read(ch)['data']
return val
except:
print("Error in pydoocs.read(): ch = ", ch)
"""
import pydoocs
import numpy as np
import matplotlib.pyplot as plt
import time
from mint.machine import Machine
from mint.snapshot import Snapshot, SnapshotDB
import basic_config
import time
from tds_images.tds_analysis import *
# DOOCS channel to scan. Fake channel
doocs_ch = "XFEL/DOOCS/CHANNEL/A.SP"
# read initial value of the doocs channel
x_0 = pydoocs.read(doocs_ch)["data"]
# scan range
x_range = np.arange(-30., 30., 2)
# define Snapshot config
snapshot = basic_config.snapshot
# init Machine
machine = Machine(snapshot)
# init DataBase
db = SnapshotDB(filename="simple_scan" + time.strftime("%Y%m%d-%H_%M_%S") +
".pcl")
# get machine snapshot before scan
df_ref = machine.get_machine_snapshot()
def get_value_ps(self, device_name):
ch = 'TTF2.MAGNETS/STEERER/' + device_name + '/PS'
self.mutex.acquire()
val = pydoocs.read(ch)['data']
self.mutex.release()
return val
def get_sext_current(self, sext):
vals = [0.0]*len(sext)#np.zeros(len(correctors))
for i in range(len(sext)):
mag_channel = "TTF2.MAGNETS/SEXT/" + sext[i]
vals[i] = pydoocs.read(mag_channel + "/PS")['data']
return vals
def get_bends_current(self, bends):
vals = [0.0]*len(bends)#np.zeros(len(correctors))
for i in range(len(bends)):
mag_channel = 'TTF2.MAGNETS/DIPOLE/' + bends[i]# + '/PS'
vals[i] = pydoocs.read(mag_channel + "/PS")['data']
return vals
def get_quads_current(self, quads):
vals = np.zeros(len(quads))
for i in range(len(quads)):
mag_channel = 'TTF2.MAGNETS/QUAD/' + quads[i]# + '/PS'
vals[i] = pydoocs.read(mag_channel + "/PS")['data']
return vals
def sase_fast(self):
nb = self.get_nbunches()
ch = 'TTF2.FEL/PHFLUX/TUNNEL/PHOTONPULSE.FF.SPECT'
data = pydoocs.read(ch)['data'][700:700 + nb - 1]
v = np.mean(np.array([x[1] for x in data]))
return v
def get_sol_value(self):
sol = pydoocs.read("TTF2.MAGNETS/SOL/1GUN/PS")
#print("sol = ", sol["data"], "A")
return sol["data"]
def get_bc3_pyros(self):
bc3_pyro = pydoocs.read("FLASH.DIAG/BCM/4DBC3.1/CH00.FLASH1")
bc3_pyro_fine = pydoocs.read("FLASH.DIAG/BCM/4DBC3.2/CH00.FLASH1")
#print("BC3 comp_fine = ", bc3_pyro["data"], bc3_pyro_fine["data"])
return (bc3_pyro["data"], bc3_pyro_fine["data"])
def get_charge(self):
charge = pydoocs.read('TTF2.FEEDBACK/LONGITUDINAL/MONITOR2/MEAN_AVG')
#print("charge = ", charge["data"], " nQ")
return charge["data"]
def assert_pydoocs_dict(self, key_list=None) -> None:
pydoocs_dict = pydoocs.read(self.doocs_addr)
if not key_list:
key_list = ["data", "macropulse"]
for key in key_list:
assert key in pydoocs_dict, '{} is missing in pydoocs dict'.format(key)
def get_nbunches(self):
nbunches = pydoocs.read(
"FLASH.DIAG/TIMER/FLASHCPUTIME1.0/NUMBER_BUNCHES.1")
#print("nbunches = ", nbunches["data"])
return nbunches["data"]
def sase_fast(self):
nb = self.get_nbunches()
ch = 'TTF2.FEL/PHFLUX/TUNNEL/PHOTONPULSE.FF.SPECT'
data = pydoocs.read(ch)['data'][700:700 + nb - 1]
v = np.mean(np.array([x[1] for x in data]))
return v
def channel_keys(self) -> collections.abc.KeysView:
pydoocs_dict = pydoocs.read(self.doocs_addr)
assert isinstance(pydoocs_dict, dict)
return pydoocs_dict.keys()
def get_sol_value(self):
sol = pydoocs.read("TTF2.MAGNETS/SOL/1GUN/PS")
#print("sol = ", sol["data"], "A")
return sol["data"]
def get_cav_ampl(self, cav):
return pydoocs.read("FLASH.RF/LLRF.CONTROLLER/PVS." + cav + "/AMPL.SAMPLE")["data"]
def get_wavelangth(self):
wavelength = pydoocs.read('TTF2.DAQ/ENERGY.DOGLEG/LAMBDA_MEAN/VAL')
#print("wavelength = ", wavelength["data"], "nm")
return wavelength["data"]
def get_cav_phase(self, cav):
return pydoocs.read("FLASH.RF/LLRF.CONTROLLER/PVS." + cav + "/PHASE.SAMPLE")["data"]
def get_final_energy(self):
final_energy = pydoocs.read("TTF2.FEEDBACK/LONGITUDINAL/MONITOR11/MEAN_AVG")
#print("final_energy = ", final_energy["data"], "MeV")
return final_energy["data"]
def get_gun_energy(self):
gun_energy = pydoocs.read("FLASH.RF/LLRF.ENERGYGAIN.ML/GUN/ENERGYGAIN.FLASH1")['data']
gun_energy = gun_energy*0.001 # MeV -> GeV
return gun_energy
def get_nbunches(self):
nbunches = pydoocs.read("FLASH.DIAG/TIMER/FLASHCPUTIME1.0/NUMBER_BUNCHES.1")
#print("nbunches = ", nbunches["data"])
return nbunches["data"]
def get_final_energy(self):
final_energy = pydoocs.read(
"TTF2.FEEDBACK/LONGITUDINAL/MONITOR11/MEAN_AVG")
#print("final_energy = ", final_energy["data"], "MeV")
return final_energy["data"]
def get_value_ps(self, device_name):
ch = 'TTF2.MAGNETS/STEERER/' + device_name + '/PS'
self.mutex.acquire()
val = pydoocs.read(ch)['data']
self.mutex.release()
return val
def get_polarity(self, quads):
vals = [0.0] * len(quads) #np.zeros(len(correctors))
for i in range(len(quads)):
mag_channel = 'TTF2.MAGNETS/QUAD/' + quads[i] # + '/PS'
vals[i] = pydoocs.read(mag_channel + "/PS.Polarity")['data']
return vals
def get_polarity(self, quads):
vals = [0.0]*len(quads)#np.zeros(len(correctors))
for i in range(len(quads)):
mag_channel = 'TTF2.MAGNETS/QUAD/' + quads[i]# + '/PS'
vals[i] = pydoocs.read(mag_channel + "/PS.Polarity")['data']
return vals
def get_current_train_id() -> int:
"""Returns current train_ID from reliable source"""
train_id = int(pydoocs.read('FLASH.FEL/TIMER/EXP2/MACRO_PULSE_NUMBER')['data'])
return train_id
