nmreval/src/gui_qt/dsc/glass_dialog.py

from itertools import cycle

from numpy import array, nan
from pyqtgraph import mkPen, mkBrush

from nmreval.lib.colors import Tab10
from ..Qt import QtWidgets, QtCore
from .._py.tnmh_dialog import Ui_Dialog
from ..lib.pg_objects import PlotItem, RegionItem

from nmreval.data import DSC


class TgCalculator(QtWidgets.QDialog, Ui_Dialog):
    def __init__(self, management, parent=None):
        super().__init__(parent=parent)

        self.setupUi(self)
        self._management = management
        self._colors = cycle(Tab10)

        self._dsc = {}
        self._plots = {}
        self._tg_value = {}
        self._fit = {}

        self.limits = RegionItem(), RegionItem()
        for lim in self.limits:
            self.graphicsView.addItem(lim)
        self._limitless = True

        self.add_sets()

        self.listWidget.itemClicked.connect(self.show_tg_values)

    def __call__(self):
        self.clear()
        self.add_sets()

    def clear(self):
        self.listWidget.clear()
        for plots in self._plots.values():
            for val in plots:
                self.graphicsView.removeItem(val)
                self.graphicsView_2.removeItem(val)

        self._dsc = {}
        self._plots = {}
        self._tg_value = {}
        self._fit = {}

    def add_sets(self):
        min_x = 10_000_000
        max_x = -10_000_000
        for (key, name), c in zip(self._management.active_sets, self._colors):
            data = self._management[key].data
            if not isinstance(data, DSC):
                continue

            min_x = min(min_x, data.x.min())
            max_x = max(max_x, data.x.max())

            item = QtWidgets.QListWidgetItem(name)
            item.setCheckState(QtCore.Qt.Checked)
            item.setData(QtCore.Qt.UserRole, key)
            item.setForeground(mkBrush(c.rgb()))
            self.listWidget.addItem(item)

            self._dsc[key] = (data, None)

            data_plot = PlotItem(x=data.x, y=data.y, pen=mkPen(c.rgb()))
            self.graphicsView.addItem(data_plot)

            glass = PlotItem()
            glass.set_line(style=2, color=c)
            self.graphicsView.addItem(glass)

            liquid = PlotItem()
            liquid.set_line(style=2, color=c)
            self.graphicsView.addItem(liquid)

            tangent = PlotItem()
            tangent.set_line(style=2, color=c)
            self.graphicsView.addItem(tangent)

            tg_plot = PlotItem(pen=None, symbolBrush=c.rgb(), symbol='o')
            self.graphicsView.addItem(tg_plot)

            fictive_cp = PlotItem(pen=mkPen(c.rgb()))
            self.graphicsView_2.addItem(fictive_cp)

            tnmh_fit = PlotItem()
            tnmh_fit.set_line(style=2, color=c)
            self.graphicsView_2.addItem(tnmh_fit)

            self._plots[key] = (data_plot, tg_plot, glass, liquid, tangent, fictive_cp, tnmh_fit)
            self._tg_value[key] = {'onset': (nan, nan), 'mid': (nan, nan), 'end': (nan, nan), 'inflection': (nan, nan), 'fictive': (nan, nan)}

        if self._limitless:
            dist = max_x - min_x
            self.limits[0].setRegion((min_x, min_x+0.1*dist))
            self.limits[1].setRegion((max_x-0.1*dist, max_x))
            self._limitless = False

    @QtCore.pyqtSlot(name='on_pushButton_clicked')
    def calc_tg(self):
        baselines = tuple(lim.getRegion() for lim in self.limits)
        if baselines[0][0] > baselines[1][0]:
            baselines = baselines[1], baselines[0]

        for idx in range(self.listWidget.count()):
            item = self.listWidget.item(idx)
            if item.checkState() == QtCore.Qt.Unchecked:
                continue

            key = item.data(QtCore.Qt.UserRole)
            plot = self._plots[key]
            data, _ = self._dsc[key]

            tg_results, glass, liquid, tangent = data.glass_transition(*baselines)

            for i, line in enumerate((glass, liquid, tangent)):
                plot[i+2].setData(x=line[:, 0], y=line[:, 1])

            self._tg_value[key].update(tg_results)

            plot[1].setData(array(list(self._tg_value[key].values())))

    def show_tg_values(self, item):
        values = self._tg_value.get(item.data(QtCore.Qt.UserRole))

        if values is not None:
            label = '\n'.join((f'{name.capitalize()}: {pos[0]:.2f} K' for name, pos in values.items()))
            self.label_3.setText(label)

        fit = self._fit.get(item.data(QtCore.Qt.UserRole))
        if fit is not None:
            self.label_5.setText(fit._parameter_string())

    @QtCore.pyqtSlot(QtWidgets.QListWidgetItem, name='on_listWidget_itemChanged')
    def change_visibility(self, item: QtWidgets.QListWidgetItem):
        is_checked = bool(item.checkState())
        plot = self._plots[item.data(QtCore.Qt.UserRole)]
        for val in plot:
            val.setVisible(is_checked)

    @QtCore.pyqtSlot(name='on_pushButton_2_clicked')
    def get_fictive(self):
        baselines = tuple(lim.getRegion() for lim in self.limits)
        if baselines[0][0] > baselines[1][0]:
            baselines = baselines[1], baselines[0]

        for idx in range(self.listWidget.count()):
            item = self.listWidget.item(idx)
            if item.checkState() == QtCore.Qt.Unchecked:
                continue

            key = item.data(QtCore.Qt.UserRole)
            plot = self._plots[key]
            data, _ = self._dsc[key]

            cp, tg = data.get_fictive_cp(*baselines)

            plot[5].setData(cp.x, cp.y)
            self._dsc[key] = (data, cp)

            self._tg_value[key]['fictive'] = (tg, 0)

            plot[1].setData(array(list(self._tg_value[key].values())))

    @QtCore.pyqtSlot(name='on_pushButton_3_clicked')
    def make_tnmh(self):
        baselines = tuple(lim.getRegion() for lim in self.limits)
        if baselines[0][0] > baselines[1][0]:
            baselines = baselines[1], baselines[0]

        for idx in range(self.listWidget.count()):
            item = self.listWidget.item(idx)
            if item.checkState() == QtCore.Qt.Unchecked:
                continue

            key = item.data(QtCore.Qt.UserRole)
            plot = self._plots[key]
            _, data = self._dsc[key]

            if data is None:
                continue

            res = data.calculate_tnmh([60, 0.5, 1, 2e5], *baselines, return_fictive=False)
            self._fit[key] = res
            plot[-1].setData(res.x, res.y)

    def close(self) -> bool:
        self.clear()
        return super().close()