def load_settings(self, event):
"""
Loads settings from the forms
"""
# TODO: change so just fills form out
# and then reads into data structure when press perform measurement
self.view1.clear_experiment_form()
self.measurement_handler.clear_queue()
file_dir, file_name = self.view1.ask_user_for_filename(
defaultDir=self.app_dir,
message='Choose a file',
wildcard='*.*',
style=wx.OPEN)
if file_dir is not None:
# try:
config_dict = load_metadata(file_name, file_dir)
settings = self._parse_config(config_dict)
for setting in settings["experiment_settings"]:
self.measurement_handler.add_to_queue(
LightPulse(setting).create_waveform(), setting)
self.temperature_settings = settings["temp_settings"]
# except Exception as e:
# print("An Exception occurred: {0}".format(e))
self.view1.set_experiment_form(self.measurement_handler.as_list())
self.view1.set_temperature_form(self.temperature_settings.as_dict())
self.measurement_handler.clear_queue()
def upload(self, event):
"""
Bulk upload settings from a text file
"""
self.measurement_handler.clear_queue()
file_dir, file_name = self.view1.ask_user_for_filename(
defaultDir=self.app_dir,
style=wx.OPEN,
message='Choose a file',
wildcard='*.*')
if file_dir is not None:
config_dict = load_metadata(file_name, file_dir)
settings = self._parse_config(config_dict)
for setting in settings["experiment_settings"]:
self.measurement_handler.add_to_queue(
LightPulse(setting).create_waveform(), setting)
self.temperature_settings = settings["temp_settings"]
self.view1.set_temperature_form(
self.temperature_settings.as_dict())
self.view1.disable_all_settings_inputs()
self.view1.show_info_modal(
"{0} experiment settings uploaded successfully!".format(
len(self.measurement_handler._queue)))
self.uploaded = True
def pc_calibration_measurement(self, calibration_settings):
null_pulse = LightPulse(calibration_settings)
self.add_to_queue(null_pulse.complete_waveform, calibration_settings)
return self.single_measurement()
def perform_measurement(self, event):
"""
Perform the queued measurements
"""
try:
if not self.uploaded:
# try to retrieve settings from the various forms
config_dict = {}
config_dict["temperature_settings"] = (
self.view1.get_temperature_form())
config_dict["wafer_settings"] = self.view1.get_wafer_form()
config_dict["experiment_settings"] = (
self.view1.get_experiment_form())
try:
settings = self._parse_config(config_dict)
except KeyError as e:
self.view1.show_error_modal(str(e))
for setting in settings["experiment_settings"]:
self.measurement_handler.add_to_queue(
LightPulse(setting).create_waveform(), setting)
self.wafer_settings = settings["wafer_settings"]
self.temperature_settings = settings["temp_settings"]
if self.data_dir is not None:
save_metadata(self.wafer_settings.as_dict(), self.data_dir,
self.wafer_settings.id)
if self.measurement_handler.is_queue_empty():
raise (PVInputError("No measurements loaded."))
# Do the actual measurements
# TODO: refactor in separate method
dataset_list = []
total_measurements = 0
self.PlotModal = PlotModal(self.app)
self.PlotModal.Show()
while not self.measurement_handler.is_queue_empty():
single_dataset = self.measurement_handler.single_measurement()
dataset_list.append(single_dataset)
total_measurements = total_measurements + 1
ts = int(time.time())
dataset_name = (str(total_measurements) +
self.wafer_settings.id + str(ts))
save_data(single_dataset, dataset_name, self.data_dir)
# print single_dataset.shape
self.PlotModal.plot_data([x for x in single_dataset[:, 1:].T])
except PVInputError as e:
self.view1.show_error_modal(str(e))
def display(self, event):
"""
Plot waveforms in modal
"""
self.PlotModal = PlotModal(self.app)
waveform_list = []
settings_dict = {}
try:
settings_dict[
"experiment_settings"] = self.view1.get_experiment_form()
experiment_settings = self._parse_experiment_settings(
settings_dict)
for setting in experiment_settings:
waveform_list.append(-LightPulse(setting).create_waveform())
self.PlotModal.Show()
self.PlotModal.plot_data(waveform_list)
except PVInputError as e:
self.view1.show_error_modal(str(e))
def single_measurement(self):
'''
This runs a single measurements:
1. Sets the femto gain
2. Generatres a waveform
3. Sends command to DAQ
4. Does next item
'''
# get measurement from list
measurement_settings = self._queue.popleft()
print 'The measurement settings are', type(measurement_settings)
print measurement_settings.ref_gain
print measurement_settings.pl_gain
# set preamp gains
self.preamps.configure(measurement_settings)
# gets the voltage pulse to control the waveform
waveform_array = LightPulse(measurement_settings).create_waveform()
# plt.figure()
# plt.plot(waveform_array)
# plt.show()
# initalises the DAQ ready for a measurement
thread = self.daq._int_thread(waveform_array, measurement_settings)
# lets get the averaging
averaging = measurement_settings.averaging
# set the variables before they are created?
thread_time = None
measurement_data = []
# perform a measurement
measurement_data, thread_time = self.daq.run_thread(thread)
# make sure the length makes sense
data_len = measurement_data.shape[0] / self.daq.NUM_CHANNELS
# print type(data_len), data_len
# print
assert (data_len.is_integer(),
"No of points per channel={0}".format(data_len))
data_len = int(data_len)
# if more averages were requested
if averaging > 1:
for i in range(averaging - 1):
thread_data, thread_time = self.daq.run_thread(thread)
# stack the data
measurement_data = np.vstack((thread_data, measurement_data))
# average the data, weighting it towards
# running total
measurement_data = np.average(measurement_data,
axis=0,
weights=(1, i + 1))
# convert into columns, putting the right data
# in the right place
measurement_data = measurement_data[:data_len *
int(self.daq.NUM_CHANNELS)]
measurement_data = measurement_data.reshape(
(data_len, int(self.daq.NUM_CHANNELS)), order='F')
assert measurement_data.shape[0] == thread_time.shape[
0], 'data Length differ {0} {1}'.format(measurement_data.shape,
thread_time.shape[0])
measurement_data = np.vstack((thread_time, measurement_data.T)).T
measurement_data = bin_data(measurement_data,
measurement_settings.binning)
return measurement_data
def setUp(self):
self.settings = ExperimentSettings()
self.lp = LightPulse(self.settings)
