def buffering(self):
if not self.connected:
print "Device not connected"
return False
count3 = PV('in_counts_3')
count4 = PV('in_counts_4')
low3 = PV('low_limit_3')
low4 = PV('low_limit_4')
trig_buffer = PV('trig_buffer')
int_time = PV('analog_out_period')
init = PV('initiate')
poll(evt=1.e-5, iot=0.01)
data1 = []
data2 = []
def getCount1(pvname, value, **kw):
data1.append(value)
def getCount2(pvname, value, **kw):
data2.append(value)
if util.put_check(
low3, 0.0) and util.put_check(low4, 0.0) and util.put_check(
trig_buffer, 1000) and util.put_fuzzy(
'analog_out_period', 10e-5, 0.05):
pass
else:
print "setting not taking place"
return False, False
time.sleep(1)
count3.add_callback(getCount1)
init.put(1)
t0 = time.time()
while time.time() - t0 < 3:
poll(evt=1.e-5, iot=0.01)
run1 = len(data1)
count3.remove_callback(1)
count3.add_callback(getCount2)
if util.put_check(trig_buffer, 500):
pass
else:
print "setting 2nd time not taking place"
return False, False
init.put(1)
t1 = time.time()
while time.time() - t1 < 3:
poll(evt=1.e-5, iot=0.01)
run2 = len(data2)
return run1, run2
def stopcount_value(self):
if not self.connected:
print "Device not connected"
return False
#util.pv_check('status', 0)
#self.stop = 1001
data1 = []
data2 = []
def getData1(pvname, value, **kw):
if value != 0:
data1.append(value)
def getData2(pvname, value, **kw):
if value != 0:
data2.append(value)
analog1 = PV('analogIn1')
stop_count = PV('outStopCount')
init = PV('initiate')
analog2 = PV('analogIn2')
poll(evt=1.e-5, iot=0.01)
analog1.wait_for_connection()
analog2.wait_for_connection()
init.wait_for_connection()
stop_count.wait_for_connection()
util.put_check(stop_count, 100)
analog1.add_callback(getData1)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 10:
poll(evt=1.e-5, iot=0.01)
first_run = len(data1)
analog1.remove_callback(0)
analog1.add_callback(getData2)
time.sleep(2)
util.put_check(stop_count, 200)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 10:
poll(evt=1.e-5, iot=0.01)
second_run = len(data2)
return first_run, second_run
class ProfMon(object):
"""Generic Profile Monitor Object Class that references profile monitor MAD name"""
def __init__(self, prof_name='OTR02'):
if prof_name not in pc.PROFS.keys():
raise ValueError('You have not specified a valid profile monitor')
prof_dict = pc.PROFS[prof_name]
self._prof_name = prof_name
self._prof_set = PV(prof_dict['set'])
self._prof_get = PV(prof_dict['get'])
self._prof_image = PV(prof_dict['image'])
self._prof_res = PV(prof_dict['res'])
self._x_size = PV(prof_dict['xsize'])
self._y_size = PV(prof_dict['ysize'])
self._rate = PV(prof_dict['rate'])
self._images = []
self._data_thread = None
self._gathering_data = False
self._get_vars = self._prof_get.get_ctrlvars()['enum_strs']
self._set_vars = self._prof_set.get_ctrlvars()['enum_strs']
self._motion_state = self._get_vars[self._prof_get.get()]
self._prof_get.add_callback(self._state_clbk, index=1)
self._insert_clbk = None
self._extract_clbk = None
def _state_clbk(self, pvName=None, value=None, char_value=None, **kw):
"""Keep track of position/motion state"""
self._motion_state = self._get_vars[value]
@property
def prof_name(self):
"""Get the profile monitor MAD name"""
return self._prof_name
@property
def cur_image(self):
"""Get the current image array"""
return self._prof_image.get()
@property
def saved_images(self):
"""Get the images collected"""
return self._images
@property
def resolution(self):
"""Get the resolution"""
return self._prof_res.get()
@property
def arr_dims(self):
"""Get the x and y dimensions"""
return (self._x_size.get(), self._y_size.get())
@property
def rate(self):
"""Get the current rate"""
return self._rate.get()
@property
def motion_state(self):
"""Get the current motion state of the profile monitor"""
return self._motion_state
@property
def state(self):
"""Get the overall state of the profile monitor"""
return self.__dict__
def insert(self, user_clbk=None):
"""Generic call to insert profile monitor, can specify callback to be run"""
if self._motion_state == pc.IN:
print('{0}: {1}'.format(self._prof_name, pc.ALREADY_INSERTED))
return
if user_clbk:
self._insert_clbk = user_clbk
self._prof_get.add_callback(self._inserted, index=0)
self._prof_set.put(pc.IN)
def _inserted(self, pv_name=None, value=None, char_value=None, **kw):
"""Generic callback after profile monitor has been inserted, default"""
if self._get_vars[value] == pc.IN:
print('{0}: {1}'.format(self._prof_name, pc.INSERTED))
if self._insert_clbk:
self._insert_clbk()
self._insert_clbk = None
self._prof_get.remove_callback(index=0)
def extract(self, usr_clbk=None):
"""Extract profile monitor command, can specify callback to be run"""
if self._motion_state == pc.OUT:
print('{0}: {1}'.format(self._prof_name, pc.ALREADY_EXTRACTED))
return
if user_clbk:
self._extract_clbk = user_clbk
self._prof_get.add_callback(self._extracted, index=0)
self._prof_set.put(pc.OUT)
def _extracted(self, pv_name=None, value=None, char_value=None, **kw):
"""Generic Callback for profile monitor that has been extracted, default"""
if self._get_vars[value] == pc.OUT:
print('{0}: {1}'.format(self._prof_name, pc.EXTRACTED))
if self._extract_clbk:
self._extract_clbk()
self._extract_clbk = None
self._prof_get.remove_callback(index=0)
def acquire_images(self, images=1):
"""Start the thread"""
self._data_thread = Thread(target=self._collect_image_data,
args=(images, ))
self._data_thread.start()
def _collect_image_data(self, images, callback):
"""Threaded data collection"""
self._gathering_data = True
delay = 1.0 / self._rate.get() # Rate must be in Hz
i = 0
while i < images:
image = self._prof_image.get()
if len(self._images) > 0 and array_equal(image, self._images[-1]):
sleep(0.01)
else:
self._images.append(image)
sleep(delay)
i += 1
if callback: # Would want this to be pyqtSignal or Event notification type thing
callback()
self._gathering_data = False
return # No join, waste of a function
class RFCon(object):
def __init__(self, station_name='GUN'):
if station_name not in sc.STATIONS.keys():
raise ValueError('You have not specified a valid RF Station')
station_dict = sc.STATIONS[station_name]
self._station_name = station_name
self._am_lim = station_dict['a_lim']
self._station_name = station_name
self._mode = PV(station_dict['mode'])
self._interval = PV(station_dict['interval'])
self._amp_set = PV(station_dict['amp_set'])
self._amp_get = PV(station_dict['amp_get'], form='time')
self._phase_set = PV(station_dict['ph_set'])
self._phase_get = PV(station_dict['ph_get'], form='time')
self._detune = PV(station_dict['detune'])
self._diff_nom = PV(station_dict['diff_nom'])
self._freq_offset = PV(station_dict['freq_offset'])
self._ssas_status = {
name: PV(name)
for name in station_dict['ssas_status']
}
self._ssa_status_vars = self._ssas_status.values()[0].get_ctrlvars(
)['enum_strs']
self._ssas_on = PV(station_dict['ssas_on'])
self._ssas_off = PV(station_dict['ssas_off'])
self._amp_data = []
self._phase_data = []
self._readings = 1
self._gathering_data = False
self._logger = logger.custom_logger(__name__)
@property
def name(self):
"""Get stations generic name"""
return self._station_name
@property
def mode(self):
"""Get detune mode"""
return self._mode.get()
@property
def interval(self):
"""Get repetion period"""
return self._interval.get()
@property
def phase(self):
"""Get current phase"""
return self._phase_get.get()
@phase.setter
def phase(self, val):
"""Set phase"""
if not isinstance(val, float) or isinstance(val, int):
self._logger.info('You have not entered an int or float')
return
self._phase_set.put(val)
@property
def amplitude(self):
"""Get current amplitude"""
return self._amp_get.get()
@amplitude.setter
def amplitude(self, val):
"""Set amplitude"""
if not isinstance(val, float) or isinstance(val, int):
self._logger.info('You have not entered an int or float')
return
if val > self.am_lim:
self._logger.info(
'You are tyring to set the amplitude too high at {0}'.format(
val))
return
if val < 0:
self._logger.info(
'You are trying to set a negative amplitude, aborting')
return
self._amp_set.put(val)
@property
def detune(self):
"""Get detune value"""
return self._detune.get()
@property
def diff_nominal(self):
"""Get diff from nominal"""
return self._diff_nom.get()
@property
def freq_offset(self):
"""Get the frequency offset"""
return self._freq_offset.get()
@freq_offset.setter
def freq_offset(self, val):
"""Set the frequency offset"""
if not isinstance(val, float) or isinstance(val, int):
self._logger.info('You have not entered an int or float')
return
self._amp_set.put(val)
@property
def amplitude_data(self):
"""Get the amplitude data"""
return self._amp_data
@property
def phase_data(self):
"""Get the phase data"""
return self._phase_data
@property
def amp_ave(self):
"""Get mean of amplitude data"""
if not self._amp_data:
self._logger.info('You have not gathering any amplitdue data')
return None
return np.mean(self._amp_data)
@property
def phase_ave(self):
"""Get the mean of the phase data"""
if not self._phase_data:
self._logger.info('You have not gathering any phase data')
return None
return np.mean(self._phase_data)
@property
def amp_std(self):
"""Get the std dev of the amplitude data"""
if not self._amp_data:
self._logger.info('You have not gathering any amplitdue data')
return None
return np.std(self._amp_data)
@property
def phase_std(self):
"""Get the std dev of the phase data"""
if not self._phase_data:
self._logger.info('You have not gathering any phase data')
return None
return np.std(self._phase_data)
@property
def ssas_status(self):
"""Get status of all SSAs for this rf station"""
return [
self._ssa_status_vars[ssa.get()]
for ssa in self._ssas_status.values()
]
def turn_off_ssas(self):
"""Turn off all SSAs"""
self._ssas_off.put(sc.OFF)
def turn_on_ssas(self):
"""Turn on all SSAs"""
self._ssas_on.put(sc.ON)
def acq_data(self, readings=1, clbk_fn=None):
"""Acquire a specified number of points to collect"""
if not isinstance(readings, int):
self._logger.info(
'You need to enter an int for number of readings')
return
if self._gathering_data:
self._logger.info('You are currently gathering data')
return
self._readings = readings
self._amp_data = []
self._phase_data = []
self._gathering_data = True
self._amp_get.add_callback(self._amp_acq_clbk,
index=0,
with_ctrlvars=False)
self._phase_get.add_callback(self._phase_acq_clbk,
index=0,
with_ctrlvars=False)
def _amp_acq_clbk(self,
pv_name=None,
value=None,
char_value=None,
timestamp=None,
**kw):
"""Amplitude callback"""
self._amp_data.append(value)
if len(self._amp_data) is self._readings:
self._logger.info("finished gathering amplitude data")
self._amp_get.remove_callback(index=0)
self._check_data_acquire()
def _phase_acq_clbk(self,
pv_name=None,
value=None,
char_value=None,
timestamp=None,
**kw):
self._phase_data.append(value)
if len(self._phase_data) is self._readings:
self._logger.info("finished gathering phase data")
self._phase_get.remove_callback(index=0)
self._check_data_acquire()
def _check_data_acquire(self):
if len(self._amp_data) == len(self._phase_data) == self._readings:
self._logger.info('All the data has been acquired')
self._gathering_data = False
def buffer_mode(self):
data = []
data2 = []
if not self.connected:
print "Device not connected"
return False
time.sleep(1)
acquisition_mode = PV('acquisition_mode')
buffered_mode = PV('buffered_acquisition')
#stop_trig_source = PV('stop_trigger_source')
stopcount = PV('stop_count')
current1 = PV('current_in_1')
init = PV('initiate')
#util.put_check(acquisition_mode, 1)
#util.put_check(buffered_mode, 1)
#util.put_check(stop_trig_source, 0)
#util.put_check(stopcount, 500)
acquisition_mode.put(1)
poll(evt=1.0, iot=1.0)
#stop_trig_source.put(1)
buffered_mode.put(1)
poll(evt=1.0, iot=1.0)
stopcount.put(500)
poll(evt=1.0, iot=1.0)
buff1 = buffered_mode.get()
def getCount(pvname, value, **kw):
data.append(value)
def getCount2(pvname, value, **kw):
data2.append(value)
print caget('buffered_acquisition')
print caget('stop_count')
print caget('acquisition_mode')
current1.add_callback(getCount)
#caput('initiate', 1)
init.put(1)
poll(evt=1.e-5, iot=0.01)
t0 = time.time()
while time.time() - t0 < 12:
poll(evt=1.e-5, iot=0.01)
#caput('initiate', 0)
poll(evt=1.e-5, iot=0.01)
#util.put_check(buffered_mode, 0)
poll(evt=1.e-5, iot=0.01)
#util.put_check(stopcount, 0)
buffered_mode.put(0)
stopcount.put(0)
poll(evt=1.e-5, iot=0.01)
# print current1.callbacks
current1.remove_callback(1)
current1.add_callback(getCount2)
poll(evt=1.e-5, iot=0.01)
#caput('initiate', 1)
init.put(1)
poll(evt=1.e-5, iot=0.01)
buff2 = buffered_mode.get()
t1 = time.time()
while time.time() - t1 < 10:
if len(data2) >= 250:
#caput('initiate', 0)
init.put(0)
break
poll(evt=1.e-5, iot=0.01)
current1.remove_callback(1)
# stopcount.disconnect()
# buffered_mode.disconnect()
# current1.disconnect()
return len(data), len(data2), buff1, buff2
class BPM(object):
"""Generic BPM Object class"""
def __init__(self, bpm_name='BPM1B'):
if bpm_name not in bc.BPMS.keys():
raise ValueError('You have not specified a valid bpm')
bpm_dict = bc.BPMS[bpm_name]
self._name = bpm_name
self._x = PV(bpm_dict['x'], form='time')
self._y = PV(bpm_dict['y'], form='time')
self._z = PV(bpm_dict['z'])
self._tmit = PV(bpm_dict['tmit'], form='time')
self._status = PV(bpm_dict['status'])
self._alarm = PV(bpm_dict['alarm'])
self._x_data = []
self._y_data = []
self._tmit_data = []
self._readings = 1
self._gathering_data = False
self._logger = logger.custom_logger(__name__)
self._data_clbk = None
self._data_thread = None
@property
def name(self):
"""Get MAD name of bpm"""
return self._name
@property
def x(self):
"""Get current x reading"""
return self._x.get()
@property
def y(self):
"""Get current y reading"""
return self._y.get()
@property
def z(self):
"""Get z position"""
return self._z.get()
@property
def tmit(self):
"""Get current tmit reading"""
return self._tmit.get()
@property
def current_data(self):
"""Get the current x, y, and tmit data tuple"""
return (self._x_data, self._y_data, self._tmit_data)
@property
def gathering_data(self):
"""Get bool indicating whether the bpm is gathering data or not"""
return self._gathering_data
@property
def x_ave(self):
"""Get the average of the x data list"""
if not self._x_data:
self._logger.info("You have no x data")
return None
return np.mean(self._x_data)
@property
def y_ave(self):
"""Get the average of the y data list"""
if not self._y_data:
self._logger.info("You have no y data")
return None
return np.mean(self._y_data)
@property
def tmit_ave(self):
"""Get the average of the tmit data list"""
if not self._tmit_data:
self._logger.info("You have no tmit data")
return None
return np.mean(self._tmit_data)
@property
def x_std(self):
"""Get the average of the x data list"""
if not self._x_data:
self._logger.info("You have no x data")
return None
return np.std(self._x_data)
@property
def y_std(self):
"""Get the average of the y data list"""
if not self._y_data:
self._logger.info("You have no y data")
return None
return np.std(self._y_data)
@property
def tmit_std(self):
"""Get the average of the tmit data list"""
if not self._tmit_data:
self._logger.info("You have no tmit data")
return None
return np.std(self._tmit_data)
@property
def status(self):
"""Get the status of the bpm"""
return self._status.get()
@property
def alarm(self):
"""Get the alarm status"""
return self._alarm.get()
def acquire_data(self, readings=1, user_clbk=None):
"""Acquire a number of readings, defaults to 1"""
if not isinstance(readings, int):
self._logger.info(
'You did not enter an int for number of readings')
return
if self._gathering_data:
self._logger.info("You are already gathering data")
return
if user_clbk:
self._data_clbk = user_clbk
self._readings = readings
self.clear_data()
self._gathering_data = True
self._data_thread = Thread(target=self.watcher)
self._data_thread.start()
self._x.add_callback(self._x_acq_clbk, index=0, with_ctrlvars=False)
self._y.add_callback(self._y_acq_clbk, index=0, with_ctrlvars=False)
self._tmit.add_callback(self._tmit_acq_clbk,
index=0,
with_ctrlvars=False)
def watcher(self):
"""Watch for all the data to be done"""
while not len(self._x_data) == len(self._y_data) == \
len(self._tmit_data) == self._readings:
time.sleep(0.1)
if self._data_clbk:
self._data_clbk()
self._data_clbk = None
return
def _x_acq_clbk(self,
pv_name=None,
value=None,
char_value=None,
time_stamp=None,
**kw):
"""x data callback"""
self._x_data.append(value)
if len(self._x_data) is self._readings:
self._x.remove_callback(0)
def _y_acq_clbk(self,
pv_name=None,
value=None,
char_value=None,
time_stamp=None,
**kw):
"""y data callback"""
self._y_data.append(value)
if len(self._y_data) is self._readings:
self._y.remove_callback(0)
def _tmit_acq_clbk(self,
pv_name=None,
value=None,
char_value=None,
time_stamp=None,
**kw):
"""tmit data callback"""
self._tmit_data.append(value)
if len(self._tmit_data) is self._readings:
self._tmit.remove_callback(0)
def clear_data(self):
"""Clear the x, y, tmit data"""
self._x_vals = []
self._y_vals = []
self._tmit_vals = []
