From b8c67a13ed7b5b1a0c7b694542bb0f2e34d29a50 Mon Sep 17 00:00:00 2001
From: Alexander Minges
Date: Mon, 21 Sep 2015 15:39:52 +0200
Subject: [PATCH] First implementation of parameter dependency analysis
in additions, averaging over rows was added
---
instruments/analytikJenaqTower2.py | 2 +
pydsf.py | 331 ++-
ui/Ui_mainwindow.py | 3905 ++++++++++++++++++++++++++++
ui/mainwindow.py | 98 +-
ui/mainwindow.ui | 134 +-
ui/mplwidget.py | 23 +-
6 files changed, 4357 insertions(+), 136 deletions(-)
diff --git a/instruments/analytikJenaqTower2.py b/instruments/analytikJenaqTower2.py
index 44146e3..6ed36fa 100644
--- a/instruments/analytikJenaqTower2.py
+++ b/instruments/analytikJenaqTower2.py
@@ -11,6 +11,8 @@ class AnalytikJenaqTower2:
self.name = "Analytik Jena qTower 2.0/2.2"
self.providesTempRange = False
self.providesDeltaT = False
+ self.wells_horizontal = 12
+ self.wells_vertical = 8
def loadData(self, filename, reads, wells):
with open(filename, 'r') as f:
diff --git a/pydsf.py b/pydsf.py
index 0b02756..8c85dcd 100644
--- a/pydsf.py
+++ b/pydsf.py
@@ -47,7 +47,12 @@ class Well:
Owned by an object of type 'Plate'.
"""
- def __init__(self, owner, name=None):
+ def __init__(self,
+ owner,
+ name=None,
+ concentration=None,
+ well_id=None,
+ empty=False):
self.owner = owner
self.name = name
self.raw = np.zeros(self.owner.reads, dtype=np.float)
@@ -58,6 +63,10 @@ class Well:
self.tm_sd = np.NaN
self.baseline_correction = owner.baseline_correction
self.baseline = None
+ self.concentration = concentration
+ self.id = well_id
+ self.empty = empty
+ self.denatured = True
def filter_raw(self):
"""
@@ -110,7 +119,7 @@ class Well:
Checks if a given value is within the defined temperature cutoff.
"""
if (value >= self.owner.tm_cutoff_low and
- value <= self.owner.tm_cutoff_high):
+ value <= self.owner.tm_cutoff_high):
return True
else:
return False
@@ -123,11 +132,13 @@ class Well:
try:
# If tm is within cutoff, perform the interpolation
if (self.temp_within_cutoff(tm)):
- tm = round(peakutils.interpolate(x, y,
+ tm = round(peakutils.interpolate(x,
+ y,
width=3,
- ind=[max_i])[0], 2)
+ ind=[max_i])[0],
+ 2)
# Remove the denatured flag
- self.owner.denatured_wells.remove(self)
+ self.denatured = False
return tm # and return the Tm
else:
return np.NaN # otherwise, return NaN
@@ -139,11 +150,15 @@ class Well:
Calculate the Tm of the well. Returns either the Tm or 'np.NaN'.
"""
# Check if the well has already been flagged as denatured
- if self in self.owner.denatured_wells:
+ # if self.denatured:
+ # return np.NaN # Return 'NaN' if true
+
+ # Check if the well is empty
+ if self.empty:
return np.NaN # Return 'NaN' if true
# First assume that the well is denatured
- self.owner.denatured_wells.append(self)
+ self.denatured = True
# Use the whole temperature range for x. We'll check the cutoff later
x = self.owner.temprange
@@ -174,6 +189,7 @@ class Well:
# melting temperature
if max_y and max_i:
tm = x[max_i]
+ self.denatured = False
return self.interpolate_tm(x, y, max_i, tm)
# if no maximum is found, return NaN
else:
@@ -188,21 +204,18 @@ class Well:
already flagged as denatured, no Tm was found, or if the initial
signal intensity is above a user definded threshold.
"""
- denatured = True # Assumption is that the well is denatured
-
- if self in self.owner.denatured_wells:
- # check if the well is already flagged as denatured
- return denatured # return true if it is
+ if self.denatured:
+ return self.denatured
if self.tm and (self.tm <= self.owner.tm_cutoff_low or
- self.tm >= self.owner.tm_cutoff_high):
- denatured = True
- return denatured
+ self.tm >= self.owner.tm_cutoff_high):
+ self.denatured = True
+ return self.denatured
for i in self.derivatives[1]:
# Iterate over all points in the first derivative
if i > 0: # If a positive slope is found
- denatured = False # set denatured flag to False
+ self.denatured = False # set denatured flag to False
reads = int(round(self.owner.reads / 10))
# How many values should be checked against the signal threshold:
@@ -210,47 +223,48 @@ class Well:
read = 0
# Initialize running variable representing the current data point
- if not denatured:
+ if not self.denatured:
for j in self.filtered: # Iterate over the filtered data
if self.owner.signal_threshold:
# If a signal threshold was defined
if j > self.owner.signal_threshold and read <= reads:
# iterate over 1/10 of all data points
# and check for values larger than the threshold.
- denatured = True
+ self.denatured = True
# Set flag to True if a match is found
print("{}: {}".format(self.name, j))
- return denatured # and return
+ return self.denatured # and return
read += 1
- return denatured
+ return self.denatured
def analyze(self):
"""
Analyse data of the well. Takes care of the calculation of derivatives,
fitting of splines to derivatives and calculation of melting point.
"""
- # apply signal filter to raw data to filter out some noise
- self.filter_raw()
- # fit a spline to unfiltered and filtered raw data
- self.splines["raw"] = self.calc_spline(self.raw)
- self.splines["filtered"] = self.calc_spline(self.filtered)
- # calculate derivatives of filtered data
- self.calc_derivatives()
- # if baseline correction is requested, calculate baseline
- if self.baseline_correction:
- self.baseline = self.calc_baseline(self.derivatives[1])
- # do an initial check if data suggest denaturation
- if self.is_denatured():
- # if appropriate, append well to denatured wells of the plate
- self.owner.denatured_wells.append(self)
- # fit a spline to the first derivative
- self.splines["derivative1"] = self.calc_spline(self.derivatives[1])
- # calculate and set melting point
- self.tm = self.calc_tm()
- # fallback: set melting point to NaN
- if self.tm is None:
- self.tm = np.NaN
+ if not self.empty:
+ # apply signal filter to raw data to filter out some noise
+ self.filter_raw()
+ # fit a spline to unfiltered and filtered raw data
+ self.splines["raw"] = self.calc_spline(self.raw)
+ self.splines["filtered"] = self.calc_spline(self.filtered)
+ # calculate derivatives of filtered data
+ self.calc_derivatives()
+ # if baseline correction is requested, calculate baseline
+ if self.baseline_correction:
+ self.baseline = self.calc_baseline(self.derivatives[1])
+ # do an initial check if data suggest denaturation
+ # if self.is_denatured():
+ # if appropriate, append well to denatured wells of the plate
+ # self.owner.denatured_wells.append(self)
+ # fit a spline to the first derivative
+ self.splines["derivative1"] = self.calc_spline(self.derivatives[1])
+ # calculate and set melting point
+ self.tm = self.calc_tm()
+ # fallback: set melting point to NaN
+ if self.tm is None:
+ self.tm = np.NaN
class Experiment:
@@ -268,7 +282,9 @@ class Experiment:
cutoff_high=None,
signal_threshold=None,
color_range=None,
- baseline_correction=False):
+ baseline_correction=False,
+ concentrations=None,
+ average_rows=None):
self.replicates = replicates
self.cols = cols
self.rows = rows
@@ -287,6 +303,8 @@ class Experiment:
self.signal_threshold = signal_threshold
self.avg_plate = None
self.baseline_correction = baseline_correction
+ self.concentrations = concentrations
+ self.average_rows = average_rows
# use cuttoff if provided, otherwise cut at edges
if cutoff_low:
self.tm_cutoff_low = cutoff_low
@@ -322,9 +340,10 @@ class Experiment:
plate.id = i
self.plates.append(plate)
i += 1
- # if more than one file is provied, assume that those are replicates
- # and add a special plate representing the average results
- if len(files) > 1:
+ # if more than one file is provided or average over rows is requested,
+ # assume that those are replicates and add a special plate
+ # representing the average results
+ if len(files) > 1 or self.average_rows:
self.avg_plate = Plate(owner=self,
filename=None,
t1=self.t1,
@@ -338,6 +357,70 @@ class Experiment:
color_range=self.color_range)
self.avg_plate.id = 'average'
+ def average_by_plates(self):
+ # iterate over all wells in a plate
+ for i in range(self.wellnum):
+ tmp = []
+ # iterate over all plates
+ for plate in self.plates:
+ tm = plate.wells[i].tm
+ self.avg_plate.wells[i].name = plate.wells[i].name
+ if not plate.wells[i].denatured:
+ # if well is not denatured, add to collection of tm
+ # values
+ tmp.append(tm)
+ if len(tmp) > 0:
+ # if at least one tm is added, calculate average
+ # and standard deviation
+ self.avg_plate.wells[i].tm = np.nanmean(tmp)
+ self.avg_plate.wells[i].tm_sd = np.nanstd(tmp)
+ self.avg_plate.wells[
+ i].concentration = plate.wells[i].concentration
+ else:
+ # otherwise add to denatured wells
+ self.avg_plate.wells[i].denatured = True
+
+ def average_by_rows(self):
+ for plate in self.plates:
+
+ for well in self.avg_plate.wells:
+ well.empty = True
+
+ i = 0
+ for column in range(plate.cols):
+ equivalent_wells = []
+ for row in range(plate.rows):
+ w = row * plate.cols + column
+ mod = (row + 1) % self.average_rows
+
+ print("Merging well {} with Tm of {}".format(
+ plate.wells[w].id, plate.wells[w].tm))
+ equivalent_wells.append(plate.wells[w].tm)
+
+ if mod == 0:
+ print(equivalent_wells)
+ mean = np.nanmean(equivalent_wells)
+ std = np.nanstd(equivalent_wells)
+ equivalent_wells = []
+ self.avg_plate.wells[i].empty = False
+ self.avg_plate.wells[i].tm = mean
+ self.avg_plate.wells[i].tm_sd = std
+ self.avg_plate.wells[i].name = plate.wells[i].name
+ self.avg_plate.wells[
+ i].concentration = plate.wells[i].concentration
+ if np.isnan(mean):
+ self.avg_plate.wells[i].denatured = True
+ print("Well {} is denatured!".format(i))
+ else:
+ self.avg_plate.wells[i].denatured = False
+ print(
+ "Adding new well with ID {}, TM {}, SD {}".format(
+ i, mean, std))
+
+ if len(equivalent_wells) == 0:
+ # i = w
+ i += 1
+
def analyze(self):
"""
Triggers analyzation of plates.
@@ -347,31 +430,15 @@ class Experiment:
# if more than one plate is present, calculate average values for the
# merged average plate
if len(self.plates) > 1:
- # iterate over all wells in a plate
- for i in range(self.wellnum):
- tmp = []
- # iterate over all plates
- for plate in self.plates:
- tm = plate.wells[i].tm
- self.avg_plate.wells[i].name = plate.wells[i].name
- if plate.wells[i] not in plate.denatured_wells:
- # if well is not denatured, add to collection of tm
- # values
- tmp.append(tm)
- if len(tmp) > 0:
- # if at least one tm is added, calculate average
- # and standard deviation
- self.avg_plate.wells[i].tm = np.mean(tmp)
- self.avg_plate.wells[i].tm_sd = np.std(tmp)
- else:
- # otherwise add to denatured wells
- append_well = self.avg_plate.wells[i]
- self.avg_plate.denatured_wells.append(append_well)
+ self.average_by_plates()
+ elif self.average_rows:
+ self.average_by_rows()
class Plate:
- def __init__(self, owner,
+ def __init__(self,
+ owner,
plate_id=None,
filename=None,
replicates=None,
@@ -383,7 +450,8 @@ class Plate:
cutoff_low=None,
cutoff_high=None,
signal_threshold=None,
- color_range=None):
+ color_range=None,
+ concentrations=None):
self.cols = cols
self.rows = rows
self.owner = owner
@@ -411,6 +479,10 @@ class Plate:
self.signal_threshold = signal_threshold
self.id = plate_id
self.baseline_correction = owner.baseline_correction
+ if concentrations is None:
+ self.concentrations = self.owner.concentrations
+ else:
+ self.concentrations = concentrations
if cutoff_low:
self.tm_cutoff_low = cutoff_low
else:
@@ -424,34 +496,21 @@ class Plate:
else:
self.color_range = None
- self.denatured_wells = []
self.tms = []
+ # TODO: Adapt for vertical concentrations
+ conc_id = 0
for i in range(self.wellnum):
- well = Well(owner=self)
+ if self.concentrations:
+ if conc_id == self.cols:
+ conc_id = 0
+ concentration = self.concentrations[conc_id]
+ conc_id += 1
+ else:
+ concentration = None
+ well = Well(owner=self, well_id=i, concentration=concentration)
self.wells.append(well)
- def analytikJena(self):
- """
- Data processing for Analytik Jena qTower 2.0 export files
- """
- with open(self.filename, 'r') as f:
- reader = csv.reader(f, delimiter=';', quoting=csv.QUOTE_NONE)
-
- i = 0
- for row in reader:
- temp = np.zeros(self.reads, dtype=float)
- for read in range(self.reads + 1):
- if read > 0:
- try:
- temp[read - 1] = row[read]
- except (IndexError, ValueError):
- temp[read - 1] = 0.0
- elif read == 0:
- self.wells[i].name = row[read]
- self.wells[i].raw = temp
- i += 1
-
def analyze(self):
try:
# Try to access data file in the given path
@@ -461,8 +520,7 @@ class Plate:
# If the file is not found, or not accessible: abort
print('Error accessing file: {}'.format(e))
- self.wells = self.instrument.loadData(self.filename,
- self.reads,
+ self.wells = self.instrument.loadData(self.filename, self.reads,
self.wells)
for well in self.wells:
@@ -540,10 +598,12 @@ class PlotResults():
c_values = [] # Array holding the color values aka Tm
dx_values = []
dy_values = []
+ ex_values = []
+ ey_values = []
canvas = widget.canvas
canvas.clear()
for well in plate.wells: # Iterate over all wells
- if well not in plate.denatured_wells:
+ if not well.denatured and not well.empty:
# Check if well is denatured (no Tm found)
c = well.tm # If not, set color to Tm
if c < plate.tm_cutoff_low:
@@ -554,6 +614,9 @@ class PlotResults():
# Check if Tm is higher that the cutoff
c = plate.tm_cutoff_high
# If it is, set color to cutoff
+ elif well.empty:
+ ex_values.append(x)
+ ey_values.append(y)
else: # If the plate is denatured
c = plate.tm_cutoff_low
# Set its color to the low cutoff
@@ -576,7 +639,8 @@ class PlotResults():
# n rows
if plate.color_range:
# plot wells and color using the colormap
- cax = ax1.scatter(x_values, y_values,
+ cax = ax1.scatter(x_values,
+ y_values,
s=305,
c=c_values,
marker='s',
@@ -584,20 +648,27 @@ class PlotResults():
vmax=plate.color_range[1])
else:
# plot wells and color using the colormap
- cax = ax1.scatter(x_values, y_values,
+ cax = ax1.scatter(x_values,
+ y_values,
s=305,
c=c_values,
marker='s')
- ax1.scatter(dx_values, dy_values,
+ ax1.scatter(dx_values, dy_values, s=305, c='white', marker='s')
+
+ ax1.scatter(dx_values,
+ dy_values,
s=80,
- c='white',
+ c='red',
marker='x',
linewidths=(1.5, ))
+
+ ax1.scatter(ex_values, ey_values, s=305, c='white', marker='s')
+
ax1.invert_yaxis() # invert y axis to math plate layout
cbar = fig1.colorbar(cax) # show colorbar
- ax1.set_xlabel(_translate('pydsf',
- 'Columns')) # set axis and colorbar label
+ # set axis and colorbar label
+ ax1.set_xlabel(_translate('pydsf', 'Columns'))
ax1.set_ylabel(_translate('pydsf', 'Rows'))
if str(plate.id) == 'average':
@@ -621,7 +692,8 @@ class PlotResults():
fig.suptitle(title + str(plate.id) + ')')
grid = mpl_toolkits.axes_grid1.Grid(
- fig, 111,
+ fig,
+ 111,
nrows_ncols=(plate.rows, plate.cols),
axes_pad=(0.15, 0.25),
add_all=True,
@@ -641,22 +713,24 @@ class PlotResults():
ax = grid[i]
# set title of current subplot to well identifier
ax.set_title(well.name, size=6)
- if well in plate.denatured_wells:
+ if well.denatured:
ax.patch.set_facecolor('#FFD6D6')
# only show three tickmarks on both axes
ax.xaxis.set_major_locator(ticker.MaxNLocator(4))
ax.yaxis.set_major_locator(ticker.MaxNLocator(4))
# check if well is denatured (without determined Tm)
- if well not in plate.denatured_wells:
+ if not well.denatured:
tm = well.tm # if not, grab its Tm
else:
tm = np.NaN # else set Tm to np.NaN
if tm:
ax.axvline(x=tm) # plot vertical line at the Tm
- ax.axvspan(plate.t1, plate.tm_cutoff_low,
+ ax.axvspan(plate.t1,
+ plate.tm_cutoff_low,
facecolor='0.8',
alpha=0.5) # shade lower cutoff area
- ax.axvspan(plate.tm_cutoff_high, plate.t2,
+ ax.axvspan(plate.tm_cutoff_high,
+ plate.t2,
facecolor='0.8',
alpha=0.5) # shade higher cutoff area
# set fontsize for all tick labels to xx-small
@@ -681,7 +755,8 @@ class PlotResults():
fig.suptitle(title + str(plate.id) + ')')
grid = mpl_toolkits.axes_grid1.Grid(
- fig, 111,
+ fig,
+ 111,
nrows_ncols=(plate.rows, plate.cols),
axes_pad=(0.15, 0.25),
add_all=True,
@@ -695,15 +770,17 @@ class PlotResults():
ax = grid[i]
# set title of current subplot to well identifier
ax.set_title(well.name, size=6)
- if well in plate.denatured_wells:
+ if well.denatured:
ax.patch.set_facecolor('#FFD6D6')
# only show three tickmarks on both axes
ax.xaxis.set_major_locator(ticker.MaxNLocator(4))
ax.yaxis.set_major_locator(ticker.MaxNLocator(4))
- ax.axvspan(plate.t1, plate.tm_cutoff_low,
+ ax.axvspan(plate.t1,
+ plate.tm_cutoff_low,
facecolor='0.8',
alpha=0.5) # shade lower cutoff area
- ax.axvspan(plate.tm_cutoff_high, plate.t2,
+ ax.axvspan(plate.tm_cutoff_high,
+ plate.t2,
facecolor='0.8',
alpha=0.5) # shade higher cutoff area
# set fontsize for all tick labels to xx-small
@@ -712,3 +789,41 @@ class PlotResults():
ax.plot(x, y)
fig.tight_layout()
canvas.draw()
+
+ def plot_concentration_dependency(self,
+ plate,
+ widget,
+ direction='horizontal',
+ parameter_label='Parameter [au]',
+ error_bars=False):
+ canvas = widget.canvas
+ canvas.clear()
+
+ fig = canvas.fig
+ title = _translate('pydsf', "Melting point vs Parameter (plate #")
+ fig.suptitle(title + str(plate.id) + ')')
+
+ ax1 = fig.add_subplot(111)
+ ax1.set_xlabel(parameter_label)
+ ax1.set_ylabel(_translate('pydsf', 'Melting point [°C]'))
+
+ for row in range(plate.rows):
+ x_values = []
+ y_values = []
+ if error_bars:
+ errors = []
+ for col in range(plate.cols):
+ well = plate.wells[row * col - 1]
+ x = well.concentration
+ y = well.tm
+ x_values.append(x)
+ y_values.append(y)
+ if error_bars:
+ errors.append(well.tm_sd)
+ if error_bars:
+ ax1.errorbar(x_values, y_values, yerr=errors, fmt='o')
+ else:
+ ax1.plot(x_values, y_values, 'o')
+
+ fig.tight_layout()
+ canvas.draw()
diff --git a/ui/Ui_mainwindow.py b/ui/Ui_mainwindow.py
index d16c4a8..9936454 100644
--- a/ui/Ui_mainwindow.py
+++ b/ui/Ui_mainwindow.py
@@ -341,3 +341,3908 @@ class Ui_MainWindow(object):
self.actionAbout.setText(_translate("MainWindow", "&About"))
self.actionAbout_Qt.setText(_translate("MainWindow", "About &Qt"))
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'mainwindow.ui'
+#
+# Created by: PyQt5 UI code generator 5.5
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+
+class Ui_MainWindow(object):
+ def setupUi(self, MainWindow):
+ MainWindow.setObjectName("MainWindow")
+ MainWindow.resize(4095, 4095)
+ sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(MainWindow.sizePolicy().hasHeightForWidth())
+ MainWindow.setSizePolicy(sizePolicy)
+ MainWindow.setLocale(QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates))
+ self.centralWidget = QtWidgets.QWidget(MainWindow)
+ self.centralWidget.setLocale(QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates))
+ self.centralWidget.setObjectName("centralWidget")
+ self.horizontalLayout = QtWidgets.QHBoxLayout(self.centralWidget)
+ self.horizontalLayout.setObjectName("horizontalLayout")
+ self.splitter = QtWidgets.QSplitter(self.centralWidget)
+ self.splitter.setOrientation(QtCore.Qt.Horizontal)
+ self.splitter.setOpaqueResize(False)
+ self.splitter.setHandleWidth(2)
+ self.splitter.setChildrenCollapsible(False)
+ self.splitter.setObjectName("splitter")
+ self.groupBox_experiment = QtWidgets.QGroupBox(self.splitter)
+ sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.groupBox_experiment.sizePolicy().hasHeightForWidth())
+ self.groupBox_experiment.setSizePolicy(sizePolicy)
+ self.groupBox_experiment.setMinimumSize(QtCore.QSize(100, 300))
+ self.groupBox_experiment.setSizeIncrement(QtCore.QSize(0, 0))
+ self.groupBox_experiment.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
+ self.groupBox_experiment.setFlat(False)
+ self.groupBox_experiment.setCheckable(False)
+ self.groupBox_experiment.setObjectName("groupBox_experiment")
+ self.formLayout_3 = QtWidgets.QFormLayout(self.groupBox_experiment)
+ self.formLayout_3.setFieldGrowthPolicy(QtWidgets.QFormLayout.ExpandingFieldsGrow)
+ self.formLayout_3.setObjectName("formLayout_3")
+ self.label_instrument = QtWidgets.QLabel(self.groupBox_experiment)
+ self.label_instrument.setObjectName("label_instrument")
+ self.formLayout_3.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.label_instrument)
+ self.comboBox_instrument = QtWidgets.QComboBox(self.groupBox_experiment)
+ sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.comboBox_instrument.sizePolicy().hasHeightForWidth())
+ self.comboBox_instrument.setSizePolicy(sizePolicy)
+ self.comboBox_instrument.setObjectName("comboBox_instrument")
+ self.comboBox_instrument.addItem("")
+ self.formLayout_3.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.comboBox_instrument)
+ self.groupBox_data = QtWidgets.QGroupBox(self.groupBox_experiment)
+ self.groupBox_data.setEnabled(True)
+ self.groupBox_data.setObjectName("groupBox_data")
+ self.gridLayout_4 = QtWidgets.QGridLayout(self.groupBox_data)
+ self.gridLayout_4.setObjectName("gridLayout_4")
+ self.buttonBox_open_reset = QtWidgets.QDialogButtonBox(self.groupBox_data)
+ sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.buttonBox_open_reset.sizePolicy().hasHeightForWidth())
+ self.buttonBox_open_reset.setSizePolicy(sizePolicy)
+ self.buttonBox_open_reset.setLayoutDirection(QtCore.Qt.LeftToRight)
+ self.buttonBox_open_reset.setOrientation(QtCore.Qt.Vertical)
+ self.buttonBox_open_reset.setStandardButtons(QtWidgets.QDialogButtonBox.Open|QtWidgets.QDialogButtonBox.Reset)
+ self.buttonBox_open_reset.setCenterButtons(False)
+ self.buttonBox_open_reset.setObjectName("buttonBox_open_reset")
+ self.gridLayout_4.addWidget(self.buttonBox_open_reset, 0, 1, 1, 1)
+ self.groupBox_replicates = QtWidgets.QGroupBox(self.groupBox_data)
+ self.groupBox_replicates.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
+ self.groupBox_replicates.setCheckable(True)
+ self.groupBox_replicates.setChecked(False)
+ self.groupBox_replicates.setObjectName("groupBox_replicates")
+ self.gridLayout_3 = QtWidgets.QGridLayout(self.groupBox_replicates)
+ self.gridLayout_3.setObjectName("gridLayout_3")
+ self.radioButton_rep_files = QtWidgets.QRadioButton(self.groupBox_replicates)
+ self.radioButton_rep_files.setEnabled(False)
+ self.radioButton_rep_files.setChecked(True)
+ self.radioButton_rep_files.setObjectName("radioButton_rep_files")
+ self.gridLayout_3.addWidget(self.radioButton_rep_files, 0, 0, 1, 1)
+ self.gridLayout_4.addWidget(self.groupBox_replicates, 2, 0, 1, 2)
+ self.listWidget_data = QtWidgets.QListWidget(self.groupBox_data)
+ self.listWidget_data.setAlternatingRowColors(True)
+ self.listWidget_data.setObjectName("listWidget_data")
+ self.gridLayout_4.addWidget(self.listWidget_data, 0, 0, 2, 1)
+ spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
+ self.gridLayout_4.addItem(spacerItem, 1, 1, 1, 1)
+ self.formLayout_3.setWidget(1, QtWidgets.QFormLayout.SpanningRole, self.groupBox_data)
+ self.groupBox_processing = QtWidgets.QGroupBox(self.groupBox_experiment)
+ self.groupBox_processing.setObjectName("groupBox_processing")
+ self.gridLayout = QtWidgets.QGridLayout(self.groupBox_processing)
+ self.gridLayout.setObjectName("gridLayout")
+ self.groupBox_temp = QtWidgets.QGroupBox(self.groupBox_processing)
+ self.groupBox_temp.setEnabled(True)
+ self.groupBox_temp.setAutoFillBackground(False)
+ self.groupBox_temp.setCheckable(False)
+ self.groupBox_temp.setObjectName("groupBox_temp")
+ self.formLayout = QtWidgets.QFormLayout(self.groupBox_temp)
+ self.formLayout.setFieldGrowthPolicy(QtWidgets.QFormLayout.ExpandingFieldsGrow)
+ self.formLayout.setLabelAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
+ self.formLayout.setFormAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignTop)
+ self.formLayout.setObjectName("formLayout")
+ self.label_tmin = QtWidgets.QLabel(self.groupBox_temp)
+ self.label_tmin.setObjectName("label_tmin")
+ self.formLayout.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.label_tmin)
+ self.doubleSpinBox_tmin = QtWidgets.QDoubleSpinBox(self.groupBox_temp)
+ self.doubleSpinBox_tmin.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
+ self.doubleSpinBox_tmin.setDecimals(1)
+ self.doubleSpinBox_tmin.setProperty("value", 20.0)
+ self.doubleSpinBox_tmin.setObjectName("doubleSpinBox_tmin")
+ self.formLayout.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.doubleSpinBox_tmin)
+ self.label_tmax = QtWidgets.QLabel(self.groupBox_temp)
+ self.label_tmax.setObjectName("label_tmax")
+ self.formLayout.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.label_tmax)
+ self.doubleSpinBox_tmax = QtWidgets.QDoubleSpinBox(self.groupBox_temp)
+ self.doubleSpinBox_tmax.setDecimals(1)
+ self.doubleSpinBox_tmax.setProperty("value", 95.0)
+ self.doubleSpinBox_tmax.setObjectName("doubleSpinBox_tmax")
+ self.formLayout.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.doubleSpinBox_tmax)
+ self.label_dt = QtWidgets.QLabel(self.groupBox_temp)
+ self.label_dt.setObjectName("label_dt")
+ self.formLayout.setWidget(2, QtWidgets.QFormLayout.LabelRole, self.label_dt)
+ self.doubleSpinBox_dt = QtWidgets.QDoubleSpinBox(self.groupBox_temp)
+ self.doubleSpinBox_dt.setDecimals(1)
+ self.doubleSpinBox_dt.setProperty("value", 1.0)
+ self.doubleSpinBox_dt.setObjectName("doubleSpinBox_dt")
+ self.formLayout.setWidget(2, QtWidgets.QFormLayout.FieldRole, self.doubleSpinBox_dt)
+ self.gridLayout.addWidget(self.groupBox_temp, 0, 0, 1, 1)
+ self.groupBox_signal_threshold = QtWidgets.QGroupBox(self.groupBox_processing)
+ self.groupBox_signal_threshold.setEnabled(True)
+ self.groupBox_signal_threshold.setCheckable(True)
+ self.groupBox_signal_threshold.setChecked(False)
+ self.groupBox_signal_threshold.setObjectName("groupBox_signal_threshold")
+ self.verticalLayout = QtWidgets.QVBoxLayout(self.groupBox_signal_threshold)
+ self.verticalLayout.setObjectName("verticalLayout")
+ self.spinBox_signal_threshold = QtWidgets.QSpinBox(self.groupBox_signal_threshold)
+ self.spinBox_signal_threshold.setMaximum(1000000)
+ self.spinBox_signal_threshold.setObjectName("spinBox_signal_threshold")
+ self.verticalLayout.addWidget(self.spinBox_signal_threshold)
+ self.gridLayout.addWidget(self.groupBox_signal_threshold, 1, 0, 1, 1)
+ self.groupBox_cbar = QtWidgets.QGroupBox(self.groupBox_processing)
+ self.groupBox_cbar.setEnabled(True)
+ self.groupBox_cbar.setCheckable(True)
+ self.groupBox_cbar.setChecked(False)
+ self.groupBox_cbar.setObjectName("groupBox_cbar")
+ self.formLayout_4 = QtWidgets.QFormLayout(self.groupBox_cbar)
+ self.formLayout_4.setFieldGrowthPolicy(QtWidgets.QFormLayout.ExpandingFieldsGrow)
+ self.formLayout_4.setObjectName("formLayout_4")
+ self.label_cbar_start = QtWidgets.QLabel(self.groupBox_cbar)
+ self.label_cbar_start.setObjectName("label_cbar_start")
+ self.formLayout_4.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.label_cbar_start)
+ self.doubleSpinBox_cbar_start = QtWidgets.QDoubleSpinBox(self.groupBox_cbar)
+ self.doubleSpinBox_cbar_start.setDecimals(1)
+ self.doubleSpinBox_cbar_start.setObjectName("doubleSpinBox_cbar_start")
+ self.formLayout_4.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.doubleSpinBox_cbar_start)
+ self.label_cbar_end = QtWidgets.QLabel(self.groupBox_cbar)
+ self.label_cbar_end.setObjectName("label_cbar_end")
+ self.formLayout_4.setWidget(2, QtWidgets.QFormLayout.LabelRole, self.label_cbar_end)
+ self.doubleSpinBox_cbar_end = QtWidgets.QDoubleSpinBox(self.groupBox_cbar)
+ self.doubleSpinBox_cbar_end.setDecimals(1)
+ self.doubleSpinBox_cbar_end.setObjectName("doubleSpinBox_cbar_end")
+ self.formLayout_4.setWidget(2, QtWidgets.QFormLayout.FieldRole, self.doubleSpinBox_cbar_end)
+ self.gridLayout.addWidget(self.groupBox_cbar, 1, 1, 1, 1)
+ self.groupBox_cutoff = QtWidgets.QGroupBox(self.groupBox_processing)
+ self.groupBox_cutoff.setEnabled(True)
+ self.groupBox_cutoff.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
+ self.groupBox_cutoff.setCheckable(True)
+ self.groupBox_cutoff.setChecked(False)
+ self.groupBox_cutoff.setObjectName("groupBox_cutoff")
+ self.formLayout_2 = QtWidgets.QFormLayout(self.groupBox_cutoff)
+ self.formLayout_2.setFieldGrowthPolicy(QtWidgets.QFormLayout.ExpandingFieldsGrow)
+ self.formLayout_2.setLabelAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
+ self.formLayout_2.setFormAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignTop)
+ self.formLayout_2.setObjectName("formLayout_2")
+ self.label_cutoff_high = QtWidgets.QLabel(self.groupBox_cutoff)
+ self.label_cutoff_high.setObjectName("label_cutoff_high")
+ self.formLayout_2.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.label_cutoff_high)
+ self.doubleSpinBox_upper = QtWidgets.QDoubleSpinBox(self.groupBox_cutoff)
+ self.doubleSpinBox_upper.setPrefix("")
+ self.doubleSpinBox_upper.setDecimals(1)
+ self.doubleSpinBox_upper.setObjectName("doubleSpinBox_upper")
+ self.formLayout_2.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.doubleSpinBox_upper)
+ self.label_cutoff_low = QtWidgets.QLabel(self.groupBox_cutoff)
+ self.label_cutoff_low.setObjectName("label_cutoff_low")
+ self.formLayout_2.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.label_cutoff_low)
+ self.doubleSpinBox_lower = QtWidgets.QDoubleSpinBox(self.groupBox_cutoff)
+ self.doubleSpinBox_lower.setDecimals(1)
+ self.doubleSpinBox_lower.setObjectName("doubleSpinBox_lower")
+ self.formLayout_2.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.doubleSpinBox_lower)
+ self.gridLayout.addWidget(self.groupBox_cutoff, 0, 1, 1, 1)
+ self.groupBox_output = QtWidgets.QGroupBox(self.groupBox_processing)
+ self.groupBox_output.setCheckable(True)
+ self.groupBox_output.setChecked(False)
+ self.groupBox_output.setObjectName("groupBox_output")
+ self.gridLayout_2 = QtWidgets.QGridLayout(self.groupBox_output)
+ self.gridLayout_2.setObjectName("gridLayout_2")
+ self.checkBox_saveplots = QtWidgets.QCheckBox(self.groupBox_output)
+ self.checkBox_saveplots.setObjectName("checkBox_saveplots")
+ self.gridLayout_2.addWidget(self.checkBox_saveplots, 1, 0, 1, 1)
+ self.buttonBox_output = QtWidgets.QDialogButtonBox(self.groupBox_output)
+ sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.buttonBox_output.sizePolicy().hasHeightForWidth())
+ self.buttonBox_output.setSizePolicy(sizePolicy)
+ self.buttonBox_output.setOrientation(QtCore.Qt.Vertical)
+ self.buttonBox_output.setStandardButtons(QtWidgets.QDialogButtonBox.Open)
+ self.buttonBox_output.setObjectName("buttonBox_output")
+ self.gridLayout_2.addWidget(self.buttonBox_output, 3, 1, 1, 1)
+ self.lineEdit_output = QtWidgets.QLineEdit(self.groupBox_output)
+ self.lineEdit_output.setObjectName("lineEdit_output")
+ self.gridLayout_2.addWidget(self.lineEdit_output, 3, 0, 1, 1)
+ self.checkBox_savetables = QtWidgets.QCheckBox(self.groupBox_output)
+ self.checkBox_savetables.setObjectName("checkBox_savetables")
+ self.gridLayout_2.addWidget(self.checkBox_savetables, 2, 0, 1, 1)
+ self.gridLayout.addWidget(self.groupBox_output, 3, 0, 1, 2)
+ self.groupBox_conc = QtWidgets.QGroupBox(self.groupBox_processing)
+ self.groupBox_conc.setMinimumSize(QtCore.QSize(0, 0))
+ self.groupBox_conc.setCheckable(True)
+ self.groupBox_conc.setChecked(False)
+ self.groupBox_conc.setObjectName("groupBox_conc")
+ self.formLayout_5 = QtWidgets.QFormLayout(self.groupBox_conc)
+ self.formLayout_5.setObjectName("formLayout_5")
+ self.lineEdit_conc = QtWidgets.QLineEdit(self.groupBox_conc)
+ self.lineEdit_conc.setObjectName("lineEdit_conc")
+ self.formLayout_5.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.lineEdit_conc)
+ self.label_conc = QtWidgets.QLabel(self.groupBox_conc)
+ self.label_conc.setObjectName("label_conc")
+ self.formLayout_5.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.label_conc)
+ self.spinBox_num_conc = QtWidgets.QSpinBox(self.groupBox_conc)
+ self.spinBox_num_conc.setObjectName("spinBox_num_conc")
+ self.formLayout_5.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.spinBox_num_conc)
+ self.label_conc_num = QtWidgets.QLabel(self.groupBox_conc)
+ self.label_conc_num.setObjectName("label_conc_num")
+ self.formLayout_5.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.label_conc_num)
+ self.gridLayout.addWidget(self.groupBox_conc, 2, 0, 1, 2)
+ self.formLayout_3.setWidget(2, QtWidgets.QFormLayout.SpanningRole, self.groupBox_processing)
+ self.buttonBox_process = QtWidgets.QDialogButtonBox(self.groupBox_experiment)
+ sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.buttonBox_process.sizePolicy().hasHeightForWidth())
+ self.buttonBox_process.setSizePolicy(sizePolicy)
+ self.buttonBox_process.setMinimumSize(QtCore.QSize(0, 0))
+ self.buttonBox_process.setStandardButtons(QtWidgets.QDialogButtonBox.NoButton)
+ self.buttonBox_process.setObjectName("buttonBox_process")
+ self.formLayout_3.setWidget(3, QtWidgets.QFormLayout.FieldRole, self.buttonBox_process)
+ self.groupBox_results = QtWidgets.QGroupBox(self.splitter)
+ self.groupBox_results.setEnabled(True)
+ sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
+ sizePolicy.setHorizontalStretch(6)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.groupBox_results.sizePolicy().hasHeightForWidth())
+ self.groupBox_results.setSizePolicy(sizePolicy)
+ self.groupBox_results.setSizeIncrement(QtCore.QSize(0, 0))
+ self.groupBox_results.setObjectName("groupBox_results")
+ self.horizontalLayout_2 = QtWidgets.QHBoxLayout(self.groupBox_results)
+ self.horizontalLayout_2.setObjectName("horizontalLayout_2")
+ self.tabWidget = QtWidgets.QTabWidget(self.groupBox_results)
+ self.tabWidget.setEnabled(True)
+ sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
+ sizePolicy.setHorizontalStretch(0)
+ sizePolicy.setVerticalStretch(0)
+ sizePolicy.setHeightForWidth(self.tabWidget.sizePolicy().hasHeightForWidth())
+ self.tabWidget.setSizePolicy(sizePolicy)
+ self.tabWidget.setMinimumSize(QtCore.QSize(300, 300))
+ self.tabWidget.setSizeIncrement(QtCore.QSize(0, 0))
+ self.tabWidget.setObjectName("tabWidget")
+ self.horizontalLayout_2.addWidget(self.tabWidget)
+ self.horizontalLayout.addWidget(self.splitter)
+ MainWindow.setCentralWidget(self.centralWidget)
+ self.menuBar = QtWidgets.QMenuBar(MainWindow)
+ self.menuBar.setGeometry(QtCore.QRect(0, 0, 4095, 30))
+ self.menuBar.setLocale(QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates))
+ self.menuBar.setObjectName("menuBar")
+ self.menuFile = QtWidgets.QMenu(self.menuBar)
+ self.menuFile.setLocale(QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates))
+ self.menuFile.setObjectName("menuFile")
+ self.menuHelp = QtWidgets.QMenu(self.menuBar)
+ self.menuHelp.setLocale(QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates))
+ self.menuHelp.setObjectName("menuHelp")
+ MainWindow.setMenuBar(self.menuBar)
+ self.statusBar = QtWidgets.QStatusBar(MainWindow)
+ self.statusBar.setObjectName("statusBar")
+ MainWindow.setStatusBar(self.statusBar)
+ self.actionQuit = QtWidgets.QAction(MainWindow)
+ self.actionQuit.setObjectName("actionQuit")
+ self.actionAbout = QtWidgets.QAction(MainWindow)
+ self.actionAbout.setObjectName("actionAbout")
+ self.actionAbout_Qt = QtWidgets.QAction(MainWindow)
+ icon = QtGui.QIcon()
+ icon.addPixmap(QtGui.QPixmap(":/qtlogo.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+ self.actionAbout_Qt.setIcon(icon)
+ self.actionAbout_Qt.setObjectName("actionAbout_Qt")
+ self.menuFile.addAction(self.actionQuit)
+ self.menuHelp.addAction(self.actionAbout)
+ self.menuHelp.addAction(self.actionAbout_Qt)
+ self.menuBar.addAction(self.menuFile.menuAction())
+ self.menuBar.addAction(self.menuHelp.menuAction())
+ self.label_instrument.setBuddy(self.comboBox_instrument)
+ self.label_tmin.setBuddy(self.doubleSpinBox_tmin)
+ self.label_tmax.setBuddy(self.doubleSpinBox_tmax)
+ self.label_dt.setBuddy(self.doubleSpinBox_dt)
+ self.label_cbar_start.setBuddy(self.doubleSpinBox_cbar_start)
+ self.label_cbar_end.setBuddy(self.doubleSpinBox_cbar_end)
+ self.label_cutoff_high.setBuddy(self.doubleSpinBox_upper)
+ self.label_cutoff_low.setBuddy(self.doubleSpinBox_lower)
+
+ self.retranslateUi(MainWindow)
+ self.tabWidget.setCurrentIndex(-1)
+ QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+ def retranslateUi(self, MainWindow):
+ _translate = QtCore.QCoreApplication.translate
+ MainWindow.setWindowTitle(_translate("MainWindow", "PyDSF"))
+ self.groupBox_experiment.setTitle(_translate("MainWindow", "Experimental Setup"))
+ self.label_instrument.setText(_translate("MainWindow", "I&nstrument"))
+ self.comboBox_instrument.setItemText(0, _translate("MainWindow", "Analytik Jena qTOWER 2.0/2.2"))
+ self.groupBox_data.setToolTip(_translate("MainWindow", "Add data files to the experiment. If multiple files are loaded, they are treated as replicates.
"))
+ self.groupBox_data.setTitle(_translate("MainWindow", "Data File"))
+ self.groupBox_replicates.setTitle(_translate("MainWindow", "Replicates"))
+ self.radioButton_rep_files.setText(_translate("MainWindow", "Files"))
+ self.groupBox_processing.setTitle(_translate("MainWindow", "Processing Options"))
+ self.groupBox_temp.setToolTip(_translate("MainWindow", "