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_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, 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 channel_keys(self) -> collections.abc.KeysView: pydoocs_dict = pydoocs.read(self.doocs_addr) assert isinstance(pydoocs_dict, dict) return pydoocs_dict.keys()
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_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