def save_splits(self):
'''Save element splits as new cut files.
'''
self.__element_losses_folder_clean_up()
dirtyinteger = 0
count = self.cut_splits.count()
for key in self.cut_splits.get_keys():
# Do not split elemental losses again.
# TODO: Should elemental losses be possible to split again?
if len(key.split('.')) == 3:
continue
main_cut = self.cut_splits.get_cut(key)
splits = self.cut_splits.get_splits(key)
split_count = len(splits)
split_number = 0
for split in splits:
new_cut = CutFile(elem_loss=True,
split_number=split_number,
split_count=split_count)
new_cut.copy_info(main_cut, split, split_count)
new_cut.save(main_cut.element_number)
split_number += 1
self.progress_bar.setValue((100 / count) * dirtyinteger \
+ (100 / count) * (split_number / split_count))
QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
# Mac requires event processing to show progress bar and its
# process.
dirtyinteger += 1
def __load_cut_splits(self, save=False):
'''Loads the checked cut files and splits them in smaller cuts.
Args:
save: Boolean representing whether we save splits or not.
'''
self.reference_cut = CutFile()
self.reference_cut.load_file(self.reference_cut_file)
# Remove old (element losses) cut files
if save:
self.__element_losses_folder_clean_up()
dirtyinteger = 0
count = len(self.checked_cuts)
for file in self.checked_cuts:
self.progress_bar.setValue((dirtyinteger / count) * 80)
QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
# Mac requires event processing to show progress bar and its process.
cut = CutFile()
cut.load_file(file)
filename_split = file.split('.')
element = Element(filename_split[1])
if len(filename_split) == 4: # Regular cut file
key = "{0}.{1}".format(element, filename_split[2])
else: # Elemental Losses cut file
key = "{0}.{1}.{2}".format(element,
filename_split[2],
filename_split[3])
self.cut_splits.add_splits(key, cut,
cut.split(self.reference_cut,
self.partition_count,
save=save))
dirtyinteger += 1
class ElementLosses:
'''Element Losses class.
'''
def __init__(self, directory_cuts, directory_elemloss, reference_cut_file,
checked_cuts, partition_count, progress_bar=Null()):
'''Inits Element Losses class.
Args:
directory_cuts: String representing cut file directory.
directory_elemloss: String representing elemental losses directory.
reference_cut_file: String representing reference cut file.
checked_cuts: String list of cut files to be graphed.
partition_count: Integer representing split count.
progress_bar: QtGui.QProgressBar or Null() if not given.
'''
self.directory_cuts = directory_cuts
self.directory_elemloss = directory_elemloss
self.partition_count = partition_count
self.checked_cuts = checked_cuts
self.progress_bar = progress_bar
# self.cut_splits_dict = {}
self.reference_cut_file = reference_cut_file
filename_split = reference_cut_file.split('.')
element = Element(filename_split[1])
self.reference_key = "{0}.{1}".format(element, filename_split[2])
self.cut_splits = ElementLossesSplitHolder()
def count_element_cuts(self, save_splits=False):
'''Count data points in splits based on reference file.
Args:
save_splits: Boolean representing whether to save element losses splits.
Return:
Returns dictionary of elements and their counts within splits.
'''
self.__load_cut_splits(save_splits)
split_counts = self.__count_element_cuts()
return split_counts
def save_splits(self):
'''Save element splits as new cut files.
'''
self.__element_losses_folder_clean_up()
dirtyinteger = 0
count = self.cut_splits.count()
for key in self.cut_splits.get_keys():
# Do not split elemental losses again.
# TODO: Should elemental losses be possible to split again?
if len(key.split('.')) == 3:
continue
main_cut = self.cut_splits.get_cut(key)
splits = self.cut_splits.get_splits(key)
split_count = len(splits)
split_number = 0
for split in splits:
new_cut = CutFile(elem_loss=True,
split_number=split_number,
split_count=split_count)
new_cut.copy_info(main_cut, split, split_count)
new_cut.save(main_cut.element_number)
split_number += 1
self.progress_bar.setValue((100 / count) * dirtyinteger \
+ (100 / count) * (split_number / split_count))
QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
# Mac requires event processing to show progress bar and its
# process.
dirtyinteger += 1
def __load_cut_splits(self, save=False):
'''Loads the checked cut files and splits them in smaller cuts.
Args:
save: Boolean representing whether we save splits or not.
'''
self.reference_cut = CutFile()
self.reference_cut.load_file(self.reference_cut_file)
# Remove old (element losses) cut files
if save:
self.__element_losses_folder_clean_up()
dirtyinteger = 0
count = len(self.checked_cuts)
for file in self.checked_cuts:
self.progress_bar.setValue((dirtyinteger / count) * 80)
QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
# Mac requires event processing to show progress bar and its process.
cut = CutFile()
cut.load_file(file)
filename_split = file.split('.')
element = Element(filename_split[1])
if len(filename_split) == 4: # Regular cut file
key = "{0}.{1}".format(element, filename_split[2])
else: # Elemental Losses cut file
key = "{0}.{1}.{2}".format(element,
filename_split[2],
filename_split[3])
self.cut_splits.add_splits(key, cut,
cut.split(self.reference_cut,
self.partition_count,
save=save))
dirtyinteger += 1
def __element_losses_folder_clean_up(self):
for the_file in os.listdir(self.directory_elemloss):
file_path = os.path.join(self.directory_elemloss, the_file)
try:
if os.path.isfile(file_path):
os.unlink(file_path)
except Exception:
# TODO: logger.error?
print("HELP! File unlink does something bad (elemloss)")
def __count_element_cuts(self):
'''Counts the number of sublists' elements to another list and puts it under
corresponding dictionary's key value.
Counts the number of sublists' elements to another list and puts it
under corresponding dictionary's key value. For example:
cuts['H'] = [[13,4,25,6],[1,3,4,1],[2,3,2]] -->
__count_element_cuts['H'] = [4,4,3]
Return:
Returns dictionary of elements and their counts within splits.
'''
split_counts_dict = {}
dirtyinteger = 0
count = self.cut_splits.count()
# for key in self.cut_splits_dict.keys():
for key in self.cut_splits.get_keys():
self.progress_bar.setValue((dirtyinteger / count) * 20 + 80)
QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
# Mac requires event processing to show progress bar and its process.
# Reference cut is not counted, excluded from graph.
if key != self.reference_key:
split_counts_dict[key] = [len(split)
for split
in self.cut_splits.get_splits(key)]
dirtyinteger += 1
return split_counts_dict
def __init__(self, measurements, settings, masses, parent_settings_dialog=None):
"""Inits the calibration dialog class.
Args:
measurements: A string list representing measurements files.
settings: A Settings class object.
masses: A Masses class object.
parent_settings_dialog: A representing from which dialog this was
opened from.
"""
super().__init__()
self.measurements = measurements
# TODO: Settings should be loaded from the measurement depending on is the
# calibration dialog opened from the project settings (measurement's
# project settings is loaded) or the measurement specific settings
# (measurement's measurement settings is loaded). This has to be done for
# better architecture.
self.settings = settings
self.__cut_file = CutFile()
self.__cut_files = {}
self.ui = uic.loadUi(os.path.join("ui_files",
"ui_calibration_dialog.ui"), self)
self.parent_settings_dialog = parent_settings_dialog
self.tof_calibration = TOFCalibration()
measurement = None
# Go through all the measurements and their cut files and list them.
for measurement in self.measurements:
item = QtGui.QTreeWidgetItem([measurement.measurement_name])
cuts, unused_cuts_elemloss = measurement.get_cut_files()
# May also return a list of cut file's element losses
# cut files as one of the list elements
for cut_file in cuts:
subitem = QtGui.QTreeWidgetItem([cut_file])
subitem.directory = measurement.directory_cuts
subitem.file_name = cut_file
item.addChild(subitem)
cut_object = CutFile()
cut_object.load_file(os.path.join(measurement.directory_cuts,
cut_file))
self.__cut_files[cut_file] = cut_object
self.ui.cutFilesTreeWidget.addTopLevelItem(item)
item.setExpanded(True)
# Resize columns to fit the content nicely
for column in range(0, self.ui.cutFilesTreeWidget.columnCount()):
self.ui.cutFilesTreeWidget.resizeColumnToContents(column)
self.curveFittingWidget = CalibrationCurveFittingWidget(self,
self.__cut_file,
self.tof_calibration,
self.settings,
self.ui.binWidthSpinBox.value(),
1,
masses)
old_params = None
if parent_settings_dialog: # Get old parameters from the parent dialog
try:
f1 = float(self.parent_settings_dialog.ui.slopeLineEdit.text())
f2 = float(self.parent_settings_dialog.ui.offsetLineEdit.text())
old_params = f1, f2
except:
m = "Can't get old calibration parameters from the settings dialog."
print(m)
self.linearFittingWidget = CalibrationLinearFittingWidget(self,
self.tof_calibration,
old_params)
self.ui.fittingResultsLayout.addWidget(self.curveFittingWidget)
self.ui.calibrationResultsLayout.addWidget(self.linearFittingWidget)
# Set up connections
self.ui.cutFilesTreeWidget.itemSelectionChanged.connect(
lambda: self.change_current_cut(
self.ui.cutFilesTreeWidget.currentItem()))
self.ui.pointsTreeWidget.itemClicked.connect(self.__set_state_for_point)
self.ui.acceptPointButton.clicked.connect(self.__accept_point)
self.ui.binWidthSpinBox.valueChanged.connect(self.__update_curve_fit)
self.ui.binWidthSpinBox.setKeyboardTracking(False)
self.ui.acceptCalibrationButton.clicked.connect(self.accept_calibration)
self.ui.cancelButton.clicked.connect(self.close)
self.ui.removePointButton.clicked.connect(self.remove_selected_points)
self.ui.tofChannelLineEdit.editingFinished.connect(
lambda: self.set_calibration_point(
float(self.ui.tofChannelLineEdit.text())))
# Set the validator for lineEdit so user can't give invalid values
double_validator = QtGui.QDoubleValidator()
self.ui.tofChannelLineEdit.setValidator(double_validator)
self.timer = QtCore.QTimer(interval=1500, timeout=self.timeout)
self.exec_()
def save_cuts(self):
"""Save cut files
Saves data points within selections into cut files.
"""
if self.selector.is_empty():
return 0
if not os.path.exists(self.directory_cuts):
os.makedirs(self.directory_cuts)
progress_bar = QtGui.QProgressBar()
self.statusbar.addWidget(progress_bar, 1)
progress_bar.show()
QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
# Mac requires event processing to show progress bar and its
# process.
starttime = time.time()
self.__remove_old_cut_files()
# Initializes the list size to match the number of selections.
points_in_selection = [[] for unused_i in range(self.selector.count())]
# Go through all points in measurement data
data_count = len(self.data)
for n in range(data_count): # while n < data_count:
if n % 5000 == 0:
# Do not always update UI to make it faster.
progress_bar.setValue((n / data_count) * 90)
QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
# Mac requires event processing to show progress bar and its
# process.
point = self.data[n]
# Check if point is within selectors' limits for faster processing.
if not self.selector.axes_limits.is_inside(point):
continue
dirtyinteger = 0 # Lazyway
for selection in self.selector.selections:
if selection.point_inside(point):
points_in_selection[dirtyinteger].append(point)
dirtyinteger += 1
# Save all found data points into appropriate element cut files
# Firstly clear old cut files so those won't be accidentally
# left there.
dirtyinteger = 0 # Increases with for, for each selection
content_length = len(points_in_selection)
for points in points_in_selection:
if points: # If not empty selection -> save
selection = self.selector.get_at(dirtyinteger)
cut_file = CutFile(self.directory)
cut_file.set_info(selection, points)
cut_file.save()
dirtyinteger += 1
progress_bar.setValue(90 + (dirtyinteger / content_length) * 10)
QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
# Mac requires event processing to show progress bar and its
# process.
self.statusbar.removeWidget(progress_bar)
progress_bar.hide()
log_msg = "Saving finished in {0} seconds.".format(time.time() - starttime)
logging.getLogger(self.measurement_name).info(log_msg)