gammaGUI-qt

#!/usr/bin/env python3
"""
Usage:
  gammaGUI-qt <file_name> [options]
  gammaGUI-qt [options]

  options:
      -o                        open a blank window
      --fwhm_at_0=<fwhm0>       fwhm value at x=0
      --min_snr=<msnr>          min SNR
      --ref_x=<xref>            x reference for fwhm_ref
      --ref_fwhm=<ref_fwhm>     fwhm ref corresponding to x_ref
      --cebr                    detector type (cerium bromide)
      --labr                    detector type (lanthanum bromide)
      --hpge                    detector type (HPGe)


Reads a csv file with the following column format: counts | energy_EUNITS,
where EUNITS can be for examle keV or MeV. It can also read a CSV file with a
single column named "counts". No need to have channels because
they are automatically infered starting from channel = 0.

If detector type is defined e.g. --cebr then the code guesses the x_ref and
fwhm_ref based on the known detector characteristics.

Note that the detector type input parameters must be changed depending on the
particular electronic gain used. The examples here are for our specific
detector configurations.
"""
import docopt
import random
import pandas as pd
import numpy as np
import datetime
from scipy import ndimage
import re
import sys
import time
from copy import deepcopy
from PyQt5.QtWidgets import *
from PyQt5.uic import loadUi
from PyQt5 import QtCore, QtWidgets, QtGui, QtWebEngineWidgets
from PyQt5.QtCore import Qt, QUrl
import matplotlib.pyplot as plt
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
from matplotlib.widgets import SpanSelector, RectangleSelector
from nasagamma import param_handle
from nasagamma import peakfit as pf
from nasagamma import peaksearch as ps
from nasagamma import spectrum as sp
from nasagamma import advanced_fit as adv
from nasagamma import tlist
from nasagamma import energy_calibration as ecal
from nasagamma import efficiency
from nasagamma import resolution
from nasagamma import file_reader
from nasagamma import read_parquet_api
from nasagamma import helper_api
from nasagamma import parse_NIST
from nasagamma import diagnostics
from nasagamma import apicalc
from nasagamma import decay_exponential as decay
import pkg_resources
import plotly.graph_objs as go
import plotly.io as pio
import tempfile


class Dialog_from_UI(QDialog):
    """Create a dialog from a UI file with a given window title."""

    def __init__(self):
        super().__init__()
        self.define_ui_vars()
        ui_file = pkg_resources.resource_filename("nasagamma", self.ui_name)
        loadUi(ui_file, self)
        self.setWindowTitle(self.window_title)


class WindowMainInfo(Dialog_from_UI):
    def define_ui_vars(self):
        self.setWindowFlag(Qt.WindowMinimizeButtonHint, True)
        self.setWindowFlag(Qt.WindowMaximizeButtonHint, True)
        self.ui_name = "win_info_main.ui"
        self.window_title = "Spectrum info"


class WindowCust(Dialog_from_UI):
    def define_ui_vars(self):
        self.setWindowFlag(Qt.WindowMinimizeButtonHint, True)
        self.setWindowFlag(Qt.WindowMaximizeButtonHint, True)
        self.ui_name = "win_customize.ui"
        self.window_title = "Customize plot"


class WindowCustInfo(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_info_customize.ui"
        self.window_title = "Customize info"


class WindowAddSubtract(Dialog_from_UI):
    def define_ui_vars(self):
        # self.setWindowFlags(Qt.WindowStaysOnTopHint)
        self.setWindowFlag(Qt.WindowMinimizeButtonHint, True)
        self.setWindowFlag(Qt.WindowMaximizeButtonHint, True)
        self.ui_name = "win_add_subtract.ui"
        self.window_title = "Add/Subtract Spectra"


class WindowAddSubtractInfo(Dialog_from_UI):
    def define_ui_vars(self):
        # self.setWindowFlags(Qt.WindowStaysOnTopHint)
        self.setWindowFlag(Qt.WindowMinimizeButtonHint, True)
        self.setWindowFlag(Qt.WindowMaximizeButtonHint, True)
        self.ui_name = "win_info_add_subt.ui"
        self.window_title = "Add/Subtract Info"


class WindowPeakFinder(Dialog_from_UI):
    def define_ui_vars(self):
        self.setWindowFlag(Qt.WindowMinimizeButtonHint, True)
        self.setWindowFlag(Qt.WindowMaximizeButtonHint, True)
        self.ui_name = "win_peak_find.ui"
        self.window_title = "Peak finder"


class WindowPeakFinderInfo(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_info_peak_find.ui"
        self.window_title = "Peak finder info"


class WindowCal(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_erg_cal.ui"
        self.window_title = "Energy calibration"


class WindowCalInfo(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_info_ecal.ui"
        self.window_title = "Energy calibration information"


class WindowCalEqns(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_erg_cal_eqns.ui"
        self.window_title = "Energy calibration: set equations"


class WindowCalAddPoint(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_erg_cal_add_point.ui"
        self.window_title = "Energy calibration: add point"


class WindowEff(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_eff.ui"
        self.window_title = "Efficiency calibration"


class WindowEffInfo(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_info_eff.ui"
        self.window_title = "Efficiency calibration information"


class WindowInfoFile(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_info_file.ui"
        self.window_title = "File information"


class WindowIsotID(Dialog_from_UI):
    def define_ui_vars(self):
        self.setWindowFlag(Qt.WindowMinimizeButtonHint, True)
        self.setWindowFlag(Qt.WindowMaximizeButtonHint, True)
        self.ui_name = "win_isot_id.ui"
        self.window_title = "Isotope ID"


class WindowIsotIDInfo(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_info_isot_id.ui"
        self.window_title = "Isotope ID info"


class WindowAdvFit(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_adv_fit.ui"
        self.window_title = "Advanced Fitting"


class WindowAPImca(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_api_mca.ui"
        self.window_title = "API MCA"


class WindowAPI3D(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_api_3D.ui"
        self.window_title = "API 3D plot"


class WindowAPIfilters(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_api_filters.ui"
        self.window_title = "Apply API filters"


class WindowPNGInfo(Dialog_from_UI):
    def define_ui_vars(self):
        self.ui_name = "win_info_png.ui"
        self.window_title = "PNG information"


class TableModel(QtCore.QAbstractTableModel):
    def __init__(self, data):
        super(TableModel, self).__init__()
        self._data = data
        self.highlighted_rows = []

    def data(self, index, role):
        row = index.row()
        column = index.column()
        if role == Qt.DisplayRole:
            value = self._data.iloc[row, column]
            return str(value)
        elif role == Qt.BackgroundRole and row in self.highlighted_rows:
            return QtGui.QColor(Qt.yellow)  # Set the desired background color
            # return QtGui.QColor(91, 115, 200)

    def set_highlighted_rows(self, rows):
        self.highlighted_rows = rows
        self.dataChanged.emit(
            self.index(0, 0), self.index(self.rowCount(0), self.columnCount(0))
        )

    def rowCount(self, index):
        return self._data.shape[0]

    def columnCount(self, index):
        return self._data.shape[1]

    def headerData(self, section, orientation, role):
        # section is the index of the column/row.
        if role == Qt.DisplayRole:
            if orientation == Qt.Horizontal:
                return str(self._data.columns[section])

            if orientation == Qt.Vertical:
                return str(self._data.index[section])

    def sort(self, Ncol, order):
        """Sort table by given column number."""
        try:
            self.layoutAboutToBeChanged.emit()
            self._data = self._data.sort_values(
                self._data.columns[Ncol], ascending=not order
            )
            self.layoutChanged.emit()
        except Exception as e:
            print(e)


class NasaGammaApp(QMainWindow):
    def __init__(self, commands):
        print(super())
        super().__init__()
        ui_file = pkg_resources.resource_filename("nasagamma", "qt_gui.ui")
        loadUi(ui_file, self)
        self.setWindowFlag(Qt.WindowMaximizeButtonHint, True)
        # self.setMinimumSize(1800, 900)
        # pixmap = QPixmap("figs/nasa-logo.jpg")
        # self.label_nasa.setPixmap(pixmap)
        # self.resize(600, 600)
        self.setWindowTitle("NASA-gamma")
        self.setWindowIcon(QtGui.QIcon("figs/NASA-gamma-logo.png"))
        self.scale = "linear"
        self.snr_state = "off"
        self.pushButton_scale.clicked.connect(self.update_scale)
        self.pushButton_scale.setStyleSheet("background-color : lightgoldenrodyellow")
        self.button_add_peak.setStyleSheet("background-color : silver")
        self.button_add_peak.setCheckable(True)
        self.button_add_peak.clicked.connect(self.add_peak)
        # push buttons
        self.enable_fitButtons(False)
        self.bg = "poly1"
        self.e_units = None
        self.pushButton_poly1.setStyleSheet("background-color : lightgreen")
        self.pushButton_poly1.setCheckable(True)
        self.pushButton_poly1.setChecked(True)
        self.pushButton_poly2.setStyleSheet("background-color : lightgreen")
        self.pushButton_poly2.setCheckable(True)
        self.pushButton_poly3.setStyleSheet("background-color : lightgreen")
        self.pushButton_poly3.setCheckable(True)
        self.pushButton_poly4.setStyleSheet("background-color : lightgreen")
        self.pushButton_poly4.setCheckable(True)
        self.pushButton_poly5.setStyleSheet("background-color : lightgreen")
        self.pushButton_poly5.setCheckable(True)
        self.pushButton_exp.setStyleSheet("background-color : lightgreen")
        self.pushButton_exp.setCheckable(True)
        self.btn_grp = QButtonGroup()
        self.btn_grp.setExclusive(True)
        self.btn_grp.addButton(self.pushButton_poly1)
        self.btn_grp.addButton(self.pushButton_poly2)
        self.btn_grp.addButton(self.pushButton_poly3)
        self.btn_grp.addButton(self.pushButton_poly4)
        self.btn_grp.addButton(self.pushButton_poly5)
        self.btn_grp.addButton(self.pushButton_exp)
        self.btn_grp.buttonClicked.connect(self.update_poly)

        # info button (main window)
        self.w_info_main = WindowMainInfo()
        self.button_info_main.clicked.connect(self.main_info_activate)

        # reset main figure
        self.button_reset.clicked.connect(self.reset_spectrum)

        # Gaussian or skewed Gaussian?
        self.sk_gauss = False
        self.pushButton_gauss.setStyleSheet("background-color : silver")
        self.pushButton_gauss.setCheckable(True)
        self.pushButton_gauss.setChecked(True)
        self.pushButton_gauss2.setStyleSheet("background-color : silver")
        self.pushButton_gauss2.setCheckable(True)
        self.btn_grp_gauss = QButtonGroup()
        self.btn_grp_gauss.setExclusive(True)
        self.btn_grp_gauss.addButton(self.pushButton_gauss)
        self.btn_grp_gauss.addButton(self.pushButton_gauss2)
        self.btn_grp_gauss.buttonClicked.connect(self.update_gauss)
        self.button_remove_cal.setStyleSheet("background-color : lightcoral")

        # customize
        self.w_cust = WindowCust()
        self.button_customize.setStyleSheet("background-color : lightsteelblue")
        self.button_customize.clicked.connect(self.new_window_custom)
        self.w_cust_info = WindowCustInfo()
        self.w_cust.button_info.clicked.connect(self.customize_info_activate)
        self.w_cust.button_apply_lab.clicked.connect(self.try_cust_labels)
        self.w_cust.button_apply_smooth.clicked.connect(self.try_cust_smooth)
        self.w_cust.button_apply_CR.clicked.connect(self.try_cust_countRate)
        self.w_cust.button_apply_shift.clicked.connect(self.try_cust_shift)

        # add/subtract spectra
        self.button_add_subtract.clicked.connect(self.activate_window_add_subtract)
        self.w_add_sub = WindowAddSubtract()
        self.w_add_sub.button_load1.clicked.connect(self.load_file1)
        self.w_add_sub.button_load2.clicked.connect(self.load_file2)
        self.w_add_sub.button_plot.clicked.connect(self.add_sub_plot)
        self.w_add_sub_info = WindowAddSubtractInfo()
        self.w_add_sub.button_info.clicked.connect(self.add_sub_info_activate)

        # navigation toolbars
        self.toolbars = []
        for tb in [
            self.main_plot,
            self.cal_plot,
            self.efficiency_plot,
            self.resolution_plot,
            self.api_plot,
            self.diag_plot00,
            self.plot_dt_png,
        ]:
            tmp = NavigationToolbar(tb.canvas, self)
            tmp.setVisible(False)
            tmp.setStyleSheet("font-size: 24px; background-color : wheat")
            self.addToolBar(tmp)
            self.toolbars.append(tmp)
        self.toolbars[0].setVisible(True)

        self.tabWidget.currentChanged.connect(self.switch_toolbar)
        self.tabWidget.setStyleSheet("background-color : whitesmoke")

        # menu bar
        self.saveFitReport.triggered.connect(self.saveReport)
        self.openFile.triggered.connect(self.load_spe_file)
        self.saveSpect.triggered.connect(self.save_spect)
        self.saveIDpeaks.triggered.connect(self.save_ID_peaks)
        self.info_file.triggered.connect(self.try_display_info_file)
        self.clearSpectrum.triggered.connect(self.clear_spectrum)

        self.initialize_main_figure()
        self.reset_main_figure()
        self.reset_spect_params()
        # remove ticks
        self.remove_ticks_fit()

        self.list_xrange = []
        self.commands = commands
        self.search = 0  # initialize dummy search object
        # peak fitting

        get_input = param_handle.get_spect_search(self.commands)
        if get_input is not None:
            (
                self.spect,
                self.search,
                self.ref_x,
                self.fwhm_at_0,
                self.ref_fwhm,
            ) = get_input
            self.e_units = self.spect.e_units
            self.fileName = self.commands["<file_name>"]
            self.create_graph(fit=True, reset=True)
        try:
            self.min_snr = float(self.commands["--min_snr"])
        except:
            print("Opening a blank GUI")

        self.button_remove_cal.clicked.connect(self.remove_cal)
        # peak search range
        self.x0 = None
        self.x1 = None

        # advanced fitting
        # TODO
        self.parea = None
        self.w_adv_fit = WindowAdvFit()
        self.button_adv_fit.clicked.connect(self.open_adv_fit)
        self.w_adv_fit.button_perform_fit.clicked.connect(self.calculate_peak_area)

        ## energy calibration
        self.mean_vals = [0]
        self.e_vals = [0]
        self.e_sigs = [0]
        self.pred_erg = 0
        self.mean_vals_not_fit = []
        self.e_vals_not_fit = []
        self.selected_rows_ecal = []
        self.cal_e_units = None
        self.df_ecal = None
        self.df_ecal_not_fit = None
        self.df_ecal_fit = None
        self.flag_check_e_units = 0
        self.flag_e_legend = 0
        self.ecal_eqn = None

        self.w_info_cal = WindowCalInfo()
        self.button_info_cal.clicked.connect(self.cal_info_activate)

        # push butons
        self.button_add_cal.setStyleSheet("background-color : lightblue")
        self.button_origin.setStyleSheet("background-color : lightgoldenrodyellow")
        self.button_apply_cal.setStyleSheet("background-color : sandybrown")
        self.button_reset_cal.setStyleSheet("background-color : lightcoral")
        self.button_cal1.setStyleSheet("background-color : lightgreen")
        self.button_cal2.setStyleSheet("background-color : lightgreen")
        self.button_cal3.setStyleSheet("background-color : lightgreen")
        self.button_cal_eqns.setStyleSheet("background-color : silver")
        self.button_origin.clicked.connect(self.set_origin)
        self.button_remove_selected.clicked.connect(self.ecal_remove_selected)

        self.button_cal1.setCheckable(True)
        self.button_cal2.setCheckable(True)
        self.button_cal3.setCheckable(True)

        self.btn_grp2 = QButtonGroup()
        self.btn_grp2.setExclusive(True)
        self.btn_grp2.addButton(self.button_cal1)
        self.btn_grp2.addButton(self.button_cal2)
        self.btn_grp2.addButton(self.button_cal3)
        self.btn_grp2.buttonClicked.connect(self.update_cal)
        self.n = 1

        self.reset_cal_figure()

        # energy textbox
        # self.button_add_cal.clicked.connect(self.add_cal)
        self.button_add_cal.clicked.connect(self.new_window_cal)
        # reset calibration
        self.button_reset_cal.clicked.connect(self.reset_cal)
        # apply calibration
        self.button_apply_cal.clicked.connect(self.apply_cal)
        # set calibration equation
        self.button_cal_eqns.clicked.connect(self.new_window_cal_eqns)
        # Add calibration point
        self.button_cal_add_point.clicked.connect(self.new_window_cal_add_point)

        ## Resolution
        # push butons
        self.button_fwhm1.setStyleSheet("background-color : lightblue")
        self.button_fwhm2.setStyleSheet("background-color : lightblue")
        self.button_add_fwhm.setStyleSheet("background-color : khaki")
        self.button_origin_fwhm.setStyleSheet("background-color : lightgoldenrodyellow")
        self.button_reset_fwhm.setStyleSheet("background-color : lightcoral")
        self.button_extrapolate.setStyleSheet("background-color : lightgreen")

        self.button_fwhm1.setCheckable(True)
        self.button_fwhm2.setCheckable(True)
        self.button_extrapolate.setCheckable(True)

        self.btn_grp3 = QButtonGroup()
        self.btn_grp3.setExclusive(True)
        self.btn_grp3.addButton(self.button_fwhm1)
        self.btn_grp3.addButton(self.button_fwhm2)

        self.btn_grp3.buttonClicked.connect(self.update_fwhm_figure)
        self.reset_fwhm_figure()
        self.fit_lst = []

        self.button_add_fwhm.clicked.connect(self.add_fwhm)
        self.button_origin_fwhm.clicked.connect(self.set_origin_fwhm)
        self.button_reset_fwhm.clicked.connect(self.reset_fwhm)
        self.button_extrapolate.clicked.connect(self.extrapolate_fwhm)

        self.fwhm_x = [0]
        self.fwhm = [0]

        ## Efficiency
        self.eff_vals = []
        self.selected_rows_eff = []
        self.eff_scale = "log"
        self.df_eff = None
        # push butons
        self.w_info_eff = WindowEffInfo()
        self.button_info_eff.clicked.connect(self.eff_info_activate)
        self.button_yscale_eff.setStyleSheet("background-color : lightgoldenrodyellow")
        self.button_yscale_eff.clicked.connect(self.eff_yscale)
        self.button_reset_eff.setStyleSheet("background-color : lightcoral")
        self.button_reset_eff.clicked.connect(self.reset_eff_all)
        self.button_fit1_eff.setStyleSheet("background-color : lightgreen")
        self.button_fit1_eff.clicked.connect(self.eff_fit1)
        self.button_fit2_eff.setStyleSheet("background-color : lightgreen")
        self.button_fit2_eff.clicked.connect(self.eff_fit2)
        self.button_add_eff.setStyleSheet("background-color : sandybrown")
        self.button_add_eff.clicked.connect(self.new_window_eff)
        self.button_remove_selected_eff.clicked.connect(self.eff_remove_selected)
        self.reset_eff_figure()

        ## Diagnostics
        self.folder_path = None
        self.button_cts_cr.setEnabled(False)
        self.button_cts_cr_fit.setEnabled(False)
        self.button_centroid_max.setEnabled(False)
        self.button_combine_send.setEnabled(False)
        self.button_diag_save.setEnabled(False)
        self.button_load_folder.clicked.connect(self.open_folder)
        self.button_fit_diag.clicked.connect(
            lambda: self.try_fit_peaks_diagnostics(integral=False)
        )
        self.button_integral_diag.clicked.connect(
            lambda: self.try_fit_peaks_diagnostics(integral=True)
        )
        self.button_diag_clear.clicked.connect(self.initialize_plots_diagnostics)
        self.button_cts_cr.clicked.connect(self.change_cts_cr_diag)
        self.button_cts_cr_fit.clicked.connect(self.change_cts_cr_fit_diag)
        self.button_centroid_max.clicked.connect(self.change_centroid_max_diag)
        self.button_combine_send.clicked.connect(self.combine_and_send_to_spect)
        self.button_diag_save.clicked.connect(self.save_multiple_spectra)

        ## API
        self.api_spect_scale = "linear"
        self.api_xy_scale = "linear"
        self.api_yscale.clicked.connect(self.api_spect_yscale)
        self.api_button_logxy.setCheckable(True)
        self.api_button_logxy.clicked.connect(self.api_xylog)
        self.api_vmax_txt.returnPressed.connect(self.api_on_returnXY)
        self.api_send_to_spect.clicked.connect(self.send_to_spect_api)
        self.api_load_file.clicked.connect(self.activate_load_api_file)
        self.api_reset.clicked.connect(self.reset_button_api)
        self.api_button_filters.clicked.connect(self.api_window_filters)
        # API 3D
        self.button_api_3D.clicked.connect(self.open_api_3D)
        # self.button_api_plot3D.clicked.connect(self.create_plot_api3D)

        # API MCA
        self.w_api_mca = WindowAPImca()
        self.button_api_mca.clicked.connect(self.open_api_mca)
        self.w_api_mca.button_apply_all.clicked.connect(self.activate_api_mca)
        self.w_api_mca.button_apply_select.clicked.connect(self.activate_api_mca_select)
        self.w_api_mca.button_reset.clicked.connect(self.reset_mca_plots)
        self.w_api_mca.button_send_to_spect.clicked.connect(self.send_to_spect_mca)
        # self.w_adv_fit.button_perform_fit.clicked.connect(self.calculate_peak_area)

        ## Find peaks
        self.button_find_peaks.setStyleSheet("background-color : mediumaquamarine")
        self.button_find_peaks.clicked.connect(self.activate_peak_finder)
        self.w_peak_find = WindowPeakFinder()
        # self.check_peak_find_groups()
        self.w_peak_find.button_kernel_apply.clicked.connect(self.peakFind_kernel_apply)
        self.w_peak_find.radioButton_hpge.clicked.connect(self.peakFind_check_hpge)
        self.w_peak_find.radioButton_labr.clicked.connect(self.peakFind_check_labr)
        self.w_peak_find.radioButton_nai.clicked.connect(self.peakFind_check_nai)
        self.w_peak_find.radioButton_plastic.clicked.connect(self.peakFind_check_plastic)
        self.w_peak_find_info = WindowPeakFinderInfo()
        self.w_peak_find.button_info.clicked.connect(self.peakFind_info_activate)

        ## Isotope ID
        self.df_isotID_selected = pd.DataFrame()
        self.df_isotID = []
        self.isotID_vlines = []
        self.button_identify_peaks.setStyleSheet("background-color : navajowhite")
        self.button_identify_peaks.clicked.connect(self.activate_isotope_id)
        self.w_isot_id = WindowIsotID()
        self.w_isot_id.isotID_button_apply.setStyleSheet("background-color : lightblue")
        self.w_isot_id.isotID_button_clear.setStyleSheet("background-color : lightcoral")
        self.w_isot_id.isotID_button_apply.clicked.connect(self.isotID_apply)
        self.w_isot_id.isotID_button_clear.clicked.connect(self.isotID_clear)
        self.w_isot_id.button_remove_vlines.setStyleSheet("background-color : lightcoral")
        self.w_isot_id.button_plot_vlines.clicked.connect(self.isotID_plot_vlines)
        self.w_isot_id.button_remove_vlines.clicked.connect(self.isotID_remove_vlines)
        self.w_isot_id.edit_element_search.returnPressed.connect(self.isotID_textSearch)
        self.w_isotID_info = WindowIsotIDInfo()
        self.w_isot_id.button_info.clicked.connect(self.isotID_info_activate)

        ## PNG
        self.w_info_png = WindowPNGInfo()
        self.button_info_png.clicked.connect(self.png_info_activate)
        self.png_spect_scale = "linear"
        self.button_yscale_png.clicked.connect(self.png_spect_yscale)
        # self.pushButton_keep_png.setCheckable(True)
        self.button_loadFile_png.clicked.connect(self.load_file_png)
        self.button_reset_png.clicked.connect(self.reset_png)
        self.pushButton_apply_tbins_png.clicked.connect(self.change_tbins_png)
        self.pushButton_apply_ebins_png.clicked.connect(self.change_ebins_png)
        self.pushButton_apply_t_png.clicked.connect(self.apply_trange_png)
        self.pushButton_apply_e_png.clicked.connect(self.apply_erange_png)
        self.pushButton_apply_dieaway_png.clicked.connect(self.apply_die_away)
        self.pushButton_apply_fit_png.clicked.connect(self.apply_die_away_fit)
        self.button_send_to_spec_png.clicked.connect(self.send_to_spect_png)
        self.initialize_plots_png()

    def main_info_activate(self):
        self.w_info_main.activateWindow()
        self.w_info_main.show()

    def switch_toolbar(self):
        current = self.tabWidget.currentIndex()
        for i, tb in enumerate(self.toolbars):
            tb.setVisible(i == current)

    def create_graph(self, fit=True, reset=True):
        # txt = f"Xrange (optional) [{self.e_units}]:"
        # self.w_peak_find.label_units.setText(txt)
        if reset:
            self.reset_main_figure()
            self.remove_ticks_fit()
            self.reset_span()
        if fit:
            self.search.plot_peaks(
                yscale=self.scale, snrs=self.snr_state, ax=self.ax_main
            )
            self.span_select()
        else:
            self.spect.plot(ax=self.ax_main, scale=self.scale)
        self.ax_main.set_yscale(self.scale)
        self.fig.canvas.draw_idle()

    def initialize_main_figure(self):
        self.fig = self.main_plot.canvas.figure  # spectrum
        self.fig_fit = self.fit_plot.canvas.figure  # residual
        self.fig.clear()
        self.fig_fit.clear()
        self.fig.set_constrained_layout(True)
        self.fig_fit.set_constrained_layout(True)
        gs = self.fig_fit.add_gridspec(2, 1, height_ratios=[0.3, 1.5])
        self.fig.patch.set_alpha(0)
        # axes
        self.ax_main = self.fig.add_subplot()
        self.ax_res = self.fig_fit.add_subplot(gs[0, 0])
        self.ax_fit = self.fig_fit.add_subplot(gs[1, 0])

        self.fig.canvas.draw_idle()
        self.fig_fit.canvas.draw_idle()

    def reset_spect_params(self):
        self.spect = 0
        self.search = 0
        self.fit = 0
        self.span = None

    def reset_main_figure(self):
        # clear axes
        # self.ax_main.clear()
        # self.ax_res.clear()
        # self.ax_fit.clear()

        if self.button_add_peak.isChecked():
            self.fig.canvas.mpl_disconnect(self.cid)
            self.button_add_peak.setChecked(False)
        self.initialize_main_figure()
        self.fig.canvas.draw_idle()
        self.fig_fit.canvas.draw_idle()

    def clear_spectrum(self):
        self.reset_spect_params()
        self.reset_main_figure()
        self.remove_ticks_fit()

    def remove_ticks_fit(self):
        self.ax_fit.set_xticks([])
        self.ax_fit.set_yticks([])
        self.ax_res.set_xticks([])
        self.ax_res.set_yticks([])

    def reset_span(self):
        if self.span is not None:
            self.span.set_active(False)
            self.span.set_visible(False)

    def update_scale(self):
        if self.scale == "log":
            self.ax_main.set_yscale("linear")
            self.scale = "linear"
        elif self.scale == "linear":
            self.ax_main.set_yscale("log")
            self.scale = "log"
        self.fig.canvas.draw_idle()

    def add_peak(self):
        if self.button_add_peak.isChecked():
            print("Waiting to add a new peak...")
            self.cid = self.fig.canvas.mpl_connect("button_press_event", self.onclick)
            if self.span is not None:
                self.span.set_active(False)
        else:
            self.fig.canvas.mpl_disconnect(self.cid)

    def onclick(self, event):
        xnew = event.xdata
        if self.spect.energies is not None:
            xnew = np.where(self.spect.energies >= xnew)[0][0]
        else:
            xnew = np.where(self.spect.channels >= xnew)[0][0]
        print(xnew)
        # if no search object initialized, initialize a dummy one
        if self.search == 0:
            self.search = ps.PeakSearch(self.spect, 420, 3, min_snr=1e6, method="scipy")
            self.span_select()
        x_idx = np.searchsorted(self.search.peaks_idx, xnew)
        self.search.peaks_idx = np.insert(self.search.peaks_idx, x_idx, xnew)
        fwhm_guess_new = self.search.fwhm(xnew)
        self.search.fwhm_guess = np.insert(self.search.fwhm_guess, x_idx, fwhm_guess_new)
        if self.spect.energies is not None:
            self.ax_main.axvline(
                x=self.spect.energies[xnew], color="red", linestyle="--", alpha=0.2
            )
        else:
            self.ax_main.axvline(
                x=self.spect.channels[xnew], color="red", linestyle="--", alpha=0.2
            )
        self.fig.canvas.draw_idle()
        self.fig.canvas.mpl_disconnect(self.cid)
        self.button_add_peak.setChecked(False)
        self.span.set_active(True)

    ## Advanced fitting
    ## TODO
    def open_adv_fit(self):
        self.w_adv_fit.activateWindow()
        self.parea = adv.PeakAreaLinearBkg(
            spectrum=self.spect, x1=self.fit.xrange[0], x2=self.fit.xrange[1]
        )
        self.w_adv_fit.show()
        self.reset_plot_adv_fit()
        self.plot_adv_fit(bool_area=False)

    def reset_plot_adv_fit(self):
        self.fig_adv_fit = self.w_adv_fit.plot_adv_fit.canvas.figure
        self.fig_adv_fit.clear()
        self.fig_adv_fit.set_constrained_layout(True)
        self.fig_adv_fit.patch.set_alpha(0)
        self.ax_area = self.fig_adv_fit.add_subplot()

    def plot_adv_fit(self, bool_area=False):
        self.parea.plot(ax=self.ax_area, areas=bool_area)
        self.fig_adv_fit.canvas.draw_idle()

    def calculate_peak_area(self):
        x1 = self.w_adv_fit.edit_x1.text()
        x2 = self.w_adv_fit.edit_x2.text()
        if self.isevaluable(x1) and self.isevaluable(x2) and self.parea is not None:
            peak_range = [eval(x1), eval(x2)]
            self.parea.calculate_peak_area(prange=peak_range)
            self.reset_plot_area()
            self.plot_area(bool_area=True)

    ## Customize plots
    def customize_info_activate(self):
        self.w_cust_info.activateWindow()
        self.w_cust_info.show()

    def new_window_custom(self):
        self.w_cust.activateWindow()
        self.w_cust.show()
        # self.w_cust.accepted.connect(self.try_customize_plot)

    def try_cust_labels(self):
        try:
            self.cust_labels()
        except Exception as e:
            print("Invalid label/constant values")
            print("An unknown error occurred:", str(e))

    def try_cust_smooth(self):
        # try:
        self.cust_smooth()
        # except:
        #     print("Invalid smoothing/rebinning values")

    def try_cust_countRate(self):
        try:
            self.cust_countRate()
        except Exception as e:
            print("Invalid count rate values")
            print("An unknown error occurred:", str(e))

    def try_cust_shift(self):
        try:
            self.cust_shift()
        except Exception as e:
            print("Invalid gain shift values")
            print("An unknown error occurred:", str(e))

    def cust_labels(self):
        description = self.w_cust.descript_txt.text()
        xlabel = self.w_cust.x_label_txt.text()
        ylabel = self.w_cust.y_label_txt.text()
        legend = self.w_cust.legend_txt.text().split(",")
        yconst = self.w_cust.yconst_txt.text()
        xconst = self.w_cust.xconst_txt.text()
        xunits = self.w_cust.xunits_txt.text()
        if description != "":
            self.spect.description = description
        if xlabel != "":
            self.ax_main.set_xlabel(xlabel)
            self.spect.x_units = xlabel
            self.fig.canvas.draw_idle()
        if ylabel != "":
            self.ax_main.set_ylabel(ylabel)
            self.spect.y_label = ylabel
            self.fig.canvas.draw_idle()
        if legend != [""]:
            legend = [x.strip() for x in legend]
            self.ax_main.legend(self.ax_main.get_legend_handles_labels()[0], legend)
            self.spect.label = legend[-1]
            self.fig.canvas.draw_idle()
        if yconst != "":
            self.spect.counts = self.spect.counts * eval(yconst)
            self.create_graph(fit=False, reset=True)
            self.search = 0
        if xconst != "":
            if self.spect.e_units is None:
                new_x = self.spect.channels * eval(xconst)
                self.e_units = f"Channels * {xconst}"
                self.spect = sp.Spectrum(
                    counts=self.spect.counts, energies=new_x, e_units=self.e_units
                )
            else:
                new_x = self.spect.energies * eval(xconst)
                self.spect = sp.Spectrum(
                    counts=self.spect.counts, energies=new_x, e_units=self.e_units
                )
            self.create_graph(fit=False, reset=True)
            self.search = 0
        if xunits != "":
            self.e_units = xunits
            self.spect.e_units = xunits
            self.spect.x_units = f"Energy ({self.e_units})"
            self.create_graph(fit=False, reset=True)
            self.search = 0

    def cust_smooth(self):
        rebin = self.w_cust.rebin_txt.text()
        moving_avg = self.w_cust.smooth_txt.text()
        if rebin != "":
            nbins = eval(rebin)
            self.spect.rebin(by=nbins)
            self.create_graph(fit=False, reset=True)
            self.search = 0
        if moving_avg != "":
            n = int(eval(moving_avg))
            self.spect.smooth(num=n)
            self.create_graph(fit=False, reset=True)
            self.search = 0

    def cust_countRate(self):
        livetime = self.w_cust.livetime_txt.text()
        if self.w_cust.checkBox_CR.isChecked():
            yl = "CPS"
            self.ax_main.set_ylabel(yl)
            self.spect.y_label = yl
            self.spect.cps = True
            self.fig.canvas.draw_idle()
        if livetime != "" and self.isevaluable(livetime) and self.spect.cps:
            self.spect.livetime = eval(livetime)
            self.create_graph(fit=False, reset=True)
            self.search = 0

    def cust_shift(self):
        gain_shift = self.w_cust.shiftBy_txt.text()
        if self.w_cust.checkBox_erg.isChecked():
            bool_erg = True
        else:
            bool_erg = False
        if gain_shift != "":
            gs = eval(gain_shift)
            self.spect.gain_shift(by=gs, energy=bool_erg)
            self.create_graph(fit=False, reset=True)
            self.search = 0

    ## Add/subtract spectra
    def add_sub_info_activate(self):
        self.w_add_sub_info.activateWindow()
        self.w_add_sub_info.show()

    def activate_window_add_subtract(self):
        self.w_add_sub.activateWindow()
        self.w_add_sub.show()

    def load_file1(self):
        try:
            self.file1, self.e_units1, self.spect1 = self.open_file()
        except Exception as e:
            self.file1 = "**ERROR loading file**"
            print("An unknown error occurred:", str(e))
        disp1 = self.file1.split("/")[-1]
        self.w_add_sub.filename1.setText(disp1)

    def load_file2(self):
        try:
            self.file2, self.e_units2, self.spect2 = self.open_file()
        except Exception as e:
            self.file2 = "**ERROR loading file**"
            print("An unknown error occurred:", str(e))
        disp2 = self.file2.split("/")[-1]
        self.w_add_sub.filename2.setText(disp2)

    def add_sub_plot(self):
        try:
            if self.w_add_sub.checkBox_add.isChecked():
                cts = self.spect1.counts + self.spect2.counts
            elif self.w_add_sub.checkBox_sub.isChecked():
                cts = self.spect1.counts - self.spect2.counts

            if self.spect1.energies is not None:
                x = self.spect1.energies
                self.spect = sp.Spectrum(counts=cts, energies=x, e_units=self.e_units1)
                self.e_units = self.e_units1
            else:
                self.spect = sp.Spectrum(counts=cts, e_units=self.e_units1)
            self.create_graph(fit=False, reset=True)
            self.search = 0
        except Exception as e:
            print("Could not perform operation")
            print("An unknown error occurred:", str(e))

    ## Fitting
    def which_button(self):
        if self.pushButton_poly1.isChecked():
            self.bg = "poly1"
        elif self.pushButton_poly2.isChecked():
            self.bg = "poly2"
        elif self.pushButton_poly3.isChecked():
            self.bg = "poly3"
        elif self.pushButton_poly4.isChecked():
            self.bg = "poly4"
        elif self.pushButton_poly5.isChecked():
            self.bg = "poly5"
        elif self.pushButton_exp.isChecked():
            self.bg = "exponential"

    def which_button_gauss(self):
        if self.pushButton_gauss2.isChecked():
            self.sk_gauss = True
        else:
            self.sk_gauss = False

    def update_poly(self):
        if len(self.list_xrange) != 0:
            self.which_button()
            try:
                self.fit = pf.PeakFit(
                    self.search, self.list_xrange[-1], bkg=self.bg, skew=self.sk_gauss
                )
                self.ax_res.clear()
                self.ax_fit.clear()
                self.fit.plot(
                    plot_type="simple",
                    fig=self.fig_fit,
                    ax_res=self.ax_res,
                    ax_fit=self.ax_fit,
                )
                data = self.get_values_table_fit()
                self.activate_fit_table(data)
            except Exception as e:
                print("update_poly: could not perform fit")
                print("An unknown error occurred:", str(e))
            self.fig_fit.canvas.draw_idle()

    def update_gauss(self):
        if len(self.list_xrange) != 0:
            self.which_button_gauss()
            try:
                self.fit = pf.PeakFit(
                    self.search, self.list_xrange[-1], bkg=self.bg, skew=self.sk_gauss
                )
                self.ax_res.clear()
                self.ax_fit.clear()
                self.fit.plot(
                    plot_type="simple",
                    fig=self.fig,
                    ax_res=self.ax_res,
                    ax_fit=self.ax_fit,
                )
                data = self.get_values_table_fit()
                self.activate_fit_table(data)
            except Exception as e:
                print("update_gauss:could not perform fit")
                print("An unknown error occurred:", str(e))
            self.fig_fit.canvas.draw_idle()

    def span_select(self):
        self.span = SpanSelector(
            self.ax_main,
            self.onselect,
            "horizontal",
            useblit=True,
            interactive=True,
            props=dict(alpha=0.3, facecolor="green"),
        )

    def enable_fitButtons(self, boolV):
        self.button_adv_fit.setEnabled(boolV)
        self.button_add_cal.setEnabled(boolV)
        self.button_add_fwhm.setEnabled(boolV)
        self.button_add_eff.setEnabled(boolV)

    def onselect(self, xmin, xmax):
        self.idxmin_fit = round(xmin, 4)
        self.idxmax_fit = round(xmax, 4)
        xrange = [self.idxmin_fit, self.idxmax_fit]
        self.list_xrange.append(xrange)
        print("xmin: ", self.idxmin_fit)
        print("xmax: ", self.idxmax_fit)
        self.ax_res.clear()
        self.ax_fit.clear()
        # try:
        self.fit = pf.PeakFit(self.search, xrange, bkg=self.bg, skew=self.sk_gauss)
        # plot_fit(fit)
        self.fit.plot(
            plot_type="simple",
            fig=self.fig_fit,
            ax_res=self.ax_res,
            ax_fit=self.ax_fit,
        )
        data = self.get_values_table_fit()
        self.activate_fit_table(data)
        self.enable_fitButtons(True)
        # except:
        #     print("onselect: Could not perform fit")
        self.fig_fit.canvas.draw_idle()

    def get_values_table_fit(self):
        cols = [
            "Mean",
            "Peak area",
            "FWHM",
            "FWHM (%)",
            "+/- Area",
            "+/- Area (%)",
        ]
        mean = []
        area = []
        fwhm = []
        fwhm_p = []
        std_mu = []
        std_A = []
        std_A_p = []
        std_fwhm = []
        for i, e in zip(self.fit.peak_info, self.fit.peak_err):
            ls = list(i.values())
            lse = list(e.values())
            mean.append(ls[0])
            area.append(ls[1])
            fwhm.append(ls[2])
            fwhm_p.append(ls[2] / ls[0] * 100)
            std_A.append(lse[1])
            std_A_p.append(lse[1] / ls[1] * 100)

        rs = np.array([mean, area, fwhm, fwhm_p, std_A, std_A_p]).T
        df = pd.DataFrame(columns=cols, data=rs)
        df = df.round(decimals=3)
        return df

    def activate_fit_table(self, data):
        # self.selected_rows = []
        self.scroll_fit = self.table_fit_area
        self.table_fit = QtWidgets.QTableView()
        self.table_fit.setAlternatingRowColors(True)
        self.table_fit.setSortingEnabled(True)
        stylesheet_header = "::section{Background-color:lightgreen}"
        self.table_fit.horizontalHeader().setStyleSheet(stylesheet_header)
        self.table_fit.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
        # self.table_fit.resizeColumnsToContents()
        self.model_fit = TableModel(data)
        self.table_fit.setModel(self.model_fit)
        self.scroll_fit.setWidget(self.table_fit)
        # print(self.table_fit.columnWidth(0))
        stylesheet_ix = "::section{Background-color:lightgoldenrodyellow}"
        self.table_fit.setStyleSheet(stylesheet_ix)
        self.table_fit.setColumnWidth(0, 150)
        self.table_fit.setColumnWidth(5, 160)

    ## energy calibration
    def cal_info_activate(self):
        self.w_info_cal.activateWindow()
        self.w_info_cal.show()

    def reset_cal_figure(self):
        self.fig_cal = self.cal_plot.canvas.figure
        self.fig_cal.clear()
        self.fig_cal.set_constrained_layout(True)
        gs2 = self.fig_cal.add_gridspec(2, 1, height_ratios=[0.3, 1.5])

        # axes
        self.ax_cal = self.fig_cal.add_subplot(gs2[1, :])
        self.ax_cal_res = self.fig_cal.add_subplot(gs2[0, :])

        # remove ticks
        self.ax_cal.set_xticks([])
        self.ax_cal.set_yticks([])
        self.ax_cal_res.set_xticks([])
        self.ax_cal_res.set_yticks([])

    def remove_cal(self):
        try:
            self.e_units = "channels"
            self.spect.remove_calibration()
            self.create_graph(fit=False, reset=True)
            self.search = 0
        except Exception as e:
            print("Cannot remove calibration")
            print("An unknown error occurred:", str(e))

    def get_mean_vals(self):
        mean_lst = []
        for d in self.fit.peak_info:
            keys = list(d)
            mean_ch = d[keys[0]]
            if self.spect.energies is not None:
                ix_ch = np.where(self.spect.energies >= mean_ch)[0][0]
                mean_ch = self.spect.channels[ix_ch]
            mean_lst.append(mean_ch)
        return mean_lst

    def append_to_list_not_repeated(self, list_e_in, list_m_in, list_e_out, list_m_out):
        for ch, e in zip(list_m_in, list_e_in):
            e2 = e.strip()  # remove white spaces
            if e2 == "_" or e2 == "-":
                next
            else:
                num_e = float(e2)
                if num_e not in list_e_out and ch not in list_m_out:
                    list_e_out.append(round(num_e, 3))
                    list_m_out.append(round(ch, 3))

    def perform_cal(self, df):
        self.ax_cal_res.clear()
        self.ax_cal.clear()
        self.pred_erg, self.efit = ecal.ecalibration(
            mean_vals=df["Centroid"],
            erg=df[f"Energy ({self.cal_e_units})"],
            channels=self.spect.channels,
            n=self.n,
            e_units=self.e_units,
            plot=True,
            residual=True,
            fig=self.fig_cal,
            ax_fit=self.ax_cal,
            ax_res=self.ax_cal_res,
        )
        # C0, C1,...
        coeffs = list(self.efit.best_values.values())
        coeffs_str = []
        for i, c in enumerate(coeffs):
            coeffs_str.append(f"{c:.4E}ch^{i}")
        self.ecal_eqn = " + ".join(coeffs_str)

    def add_point_dont_fit(self, erg_lst=None, ch_lst=None):

        if erg_lst is not None and ch_lst is not None:
            en, mean_lst = self.retrieve_evals()
            self.append_to_list_not_repeated(
                en, mean_lst, self.e_vals_not_fit, self.mean_vals_not_fit
            )
        self.df_ecal_not_fit = pd.DataFrame()
        self.df_ecal_not_fit["Centroid"] = self.mean_vals_not_fit
        self.df_ecal_not_fit[f"Energy ({self.cal_e_units})"] = self.e_vals_not_fit
        self.df_ecal_not_fit[f"Sigma ({self.cal_e_units})"] = [0] * len(
            self.mean_vals_not_fit
        )
        if self.df_ecal_fit is not None:
            self.df_ecal = pd.concat(
                [self.df_ecal_fit, self.df_ecal_not_fit], ignore_index=True
            )
        else:
            self.df_ecal = self.df_ecal_not_fit

    def plot_point_dont_fit(self):
        if len(self.mean_vals_not_fit) > 0:
            self.ax_cal.plot(
                self.mean_vals_not_fit,
                self.e_vals_not_fit,
                "o",
                color="black",
                ms=8,
                markerfacecolor="yellow",
                label="Not used for fit",
            )
            if self.flag_e_legend == 0:
                self.ax_cal.legend()
                self.flag_e_legend = 1
            self.fig_cal.canvas.draw_idle()

    def add_point_fit(self, erg_lst=None, ch_lst=None):
        if len(self.mean_vals) > 0:
            if erg_lst is not None and ch_lst is not None:
                en, mean_lst = self.retrieve_evals()
                self.append_to_list_not_repeated(
                    en, mean_lst, self.e_vals, self.mean_vals
                )
            self.df_ecal_fit = pd.DataFrame()
            self.df_ecal_fit["Centroid"] = self.mean_vals
            self.df_ecal_fit[f"Energy ({self.cal_e_units})"] = self.e_vals
            self.df_ecal_fit[f"Sigma ({self.cal_e_units})"] = [0] * len(self.mean_vals)
            self.perform_cal(self.df_ecal_fit)
            self.df_ecal_fit[f"Sigma ({self.cal_e_units})"] = list(
                self.efit.eval_uncertainty()
            )
            if self.df_ecal_not_fit is not None:
                self.df_ecal = pd.concat(
                    [self.df_ecal_not_fit, self.df_ecal_fit], ignore_index=True
                )
            else:
                self.df_ecal = self.df_ecal_fit

    def add_cal(self):
        try:
            self.check_radioButton()
            self.flag_check_e_units = 1
            cols = [
                "Centroid",
                f"Energy ({self.cal_e_units})",
                f"Sigma ({self.cal_e_units})",
            ]
            self.df_ecal = pd.DataFrame(columns=cols)
            erg, mean_vals = self.retrieve_evals()
            if self.w_cal.checkBox_cal.isChecked():
                self.add_point_dont_fit(erg, mean_vals)
                self.plot_point_dont_fit()
            else:
                self.add_point_fit(erg, mean_vals)
            self.update_ecal_table()
            self.fig_cal.canvas.draw_idle()
        except Exception as e:
            print("Not valid entry for energy calibration")
            print("An unknown error occurred:", str(e))

    def retrieve_evals(self):
        erg = self.w_cal.energy_txt.text().split(",")
        mean_lst = self.get_mean_vals()
        return erg, mean_lst

    def new_window_cal(self):
        self.w_cal = WindowCal()
        self.w_cal.show()
        self.w_cal.accepted.connect(self.add_cal)
        if self.flag_check_e_units == 1:
            if self.e_units == "eV":
                self.w_cal.radio_button_ev.setChecked(True)
            if self.e_units == "keV":
                self.w_cal.radio_button_kev.setChecked(True)
            if self.e_units == "MeV":
                self.w_cal.radio_button_mev.setChecked(True)
            self.disable_checkRadioButtons()
            txt = "Note: calibration has already been initialized"
            self.w_cal.label_ecal_warning.setText(txt)
            self.w_cal.label_ecal_warning.setStyleSheet("color: red ; font: 10")

    def check_radioButton(self):
        if self.w_cal.radio_button_ev.isChecked():
            self.e_units = "eV"
            self.cal_e_units = "eV"
        elif self.w_cal.radio_button_kev.isChecked():
            self.e_units = "keV"
            self.cal_e_units = "keV"
        elif self.w_cal.radio_button_mev.isChecked():
            self.e_units = "MeV"
            self.cal_e_units = "MeV"
        else:
            msg = "ERROR: energy units not determined. Will use channels instead"
            print(msg)

    def disable_checkRadioButtons(self):
        self.w_cal.radio_button_ev.setEnabled(False)
        self.w_cal.radio_button_kev.setEnabled(False)
        self.w_cal.radio_button_mev.setEnabled(False)

    def update_ecal_table(self):
        # self.df_ecal = self.get_ecal_values()
        self.df_ecal.fillna(value=0, inplace=True)
        self.df_ecal.sort_values(by=["Centroid"], inplace=True, ignore_index=True)
        self.df_ecal = self.df_ecal.round(3)
        self.activate_ecal_table(data=self.df_ecal)

    def activate_ecal_table(self, data):
        self.selected_rows_ecal = []
        self.table_ecal = QtWidgets.QTableView()
        self.table_ecal.setAlternatingRowColors(True)
        self.table_ecal.setSortingEnabled(False)
        stylesheet_header = "::section{Background-color:lightgreen}"
        self.table_ecal.horizontalHeader().setStyleSheet(stylesheet_header)
        self.table_ecal.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
        # self.table_ecal.resizeColumnsToContents()
        self.model_ecal = TableModel(data)
        ix_not_fit = self.get_index_not_fit_ecal_table()
        self.color_table_rows(ix_not_fit)
        self.table_ecal.setModel(self.model_ecal)
        self.table_ecal_area.setWidget(self.table_ecal)
        stylesheet_ix = "::section{Background-color:lightgoldenrodyellow}"
        self.table_ecal.setStyleSheet(stylesheet_ix)
        self.table_ecal.setColumnWidth(0, 150)
        self.table_ecal.setColumnWidth(1, 150)
        self.table_ecal.setColumnWidth(2, 150)
        self.table_ecal.selectionModel().selectionChanged.connect(
            self.on_selectionChanged_ecal
        )

    def get_index_not_fit_ecal_table(self):
        ix = []
        for row in self.df_ecal.index:
            erg = self.df_ecal.iloc[row][f"Energy ({self.cal_e_units})"]
            if erg in self.e_vals_not_fit:
                ix.append(row)
        return ix

    def color_table_rows(self, index):
        self.model_ecal.set_highlighted_rows(index)

    def on_selectionChanged_ecal(self, selected, deselected):
        for ix in selected.indexes():
            self.selected_rows_ecal.append(ix.row())
        for ix in deselected.indexes():
            try:
                self.selected_rows_ecal.remove(ix.row())
            except ValueError:
                pass
        self.selected_rows_ecal = list(set(self.selected_rows_ecal))
        self.selected_indexes_ecal = list(
            self.model_ecal._data.index[self.selected_rows_ecal]
        )

    def set_origin(self):
        self.ax_cal.clear()
        if 0 in self.mean_vals:
            self.mean_vals.pop(0)
            self.e_vals.pop(0)
        else:
            self.mean_vals.insert(0, 0)
            self.e_vals.insert(0, 0)

        if len(self.mean_vals) > 1:
            self.add_point_fit()
            self.plot_point_dont_fit()
            self.update_ecal_table()
            self.fig_cal.canvas.draw_idle()

    def which_button_cal(self):
        if self.button_cal1.isChecked():
            self.n = 1
        elif self.button_cal2.isChecked():
            self.n = 2
        elif self.button_cal3.isChecked():
            self.n = 3

    def update_cal(self):
        try:
            # df = self.df_ecal.query(f"Centroid in {self.mean_vals}")
            # df.reset_index(drop=True, inplace=True)
            self.which_button_cal()
            self.ax_cal.clear()
            self.add_point_fit()
            self.add_point_dont_fit()
            self.plot_point_dont_fit()
            self.update_ecal_table()
            self.fig_cal.canvas.draw_idle()
        except Exception as e:
            print("Calibration data not updated")
            print("An unknown error occurred:", str(e))

    def new_window_cal_eqns(self):
        self.w_cal_eqns = WindowCalEqns()
        self.w_cal_eqns.show()
        self.w_cal_eqns.accepted.connect(self.add_cal_eqns)

    def add_cal_eqns(self):
        try:
            a_txt = self.w_cal_eqns.a.text()
            b_txt = self.w_cal_eqns.b.text()
            c_txt = self.w_cal_eqns.c.text()
            d_txt = self.w_cal_eqns.d.text()
            ch = self.spect.channels
            erg = 0
            self.ecal_eqn = ""
            if self.isevaluable(a_txt):
                erg = erg + eval(a_txt)
                self.ecal_eqn = self.ecal_eqn + f"{eval(a_txt)}"
            if self.isevaluable(b_txt):
                erg = erg + eval(b_txt) * ch
                self.ecal_eqn = self.ecal_eqn + f" + {eval(b_txt)}x"
            if self.isevaluable(c_txt):
                erg = erg + eval(c_txt) * ch**2
                self.ecal_eqn = self.ecal_eqn + f" + {eval(c_txt)}x^2"
            if self.isevaluable(d_txt):
                erg = erg + eval(d_txt) * ch**3
                self.ecal_eqn = self.ecal_eqn + f" + {eval(d_txt)}x^3"
            self.pred_erg = erg
            self.which_button_cal_eqn()
            self.plot_cal_eqns(self.ecal_eqn)
        except Exception as e:
            print("Could not set calibration equations")
            print("An unknown error occurred:", str(e))

    def plot_cal_eqns(self, label):
        self.reset_cal()
        self.ax_cal.clear()
        self.ax_cal.plot(self.spect.channels, self.pred_erg, lw=3, label=label)
        self.ax_cal.set_xlabel("Channels")
        self.ax_cal.set_ylabel("Energy (keV)")
        self.ax_cal.legend(fontsize=16)
        self.fig_cal.canvas.draw_idle()

    def which_button_cal_eqn(self):
        if self.w_cal_eqns.radio_button_ev.isChecked():
            self.cal_e_units = "eV"
        elif self.w_cal_eqns.radio_button_kev.isChecked():
            self.cal_e_units = "keV"
        elif self.w_cal_eqns.radio_button_mev.isChecked():
            self.cal_e_units = "MeV"

    def reset_cal(self):
        print("Reseting calibration")
        self.ax_cal.clear()
        self.ax_cal_res.clear()
        self.mean_vals = [0]
        self.e_vals = [0]
        self.mean_vals_not_fit = []
        self.e_vals_not_fit = []
        self.flag_check_e_units = 0
        cols = ["Centroid", "Energy", "Sigma"]
        self.df_ecal = pd.DataFrame(columns=cols)
        self.update_ecal_table()
        # remove ticks
        self.ax_cal.set_xticks([])
        self.ax_cal.set_yticks([])
        self.ax_cal_res.set_xticks([])
        self.ax_cal_res.set_yticks([])
        self.fig_cal.canvas.draw_idle()

    def apply_cal(self):
        try:
            if self.cal_e_units is None:
                e_units = self.spect.e_units
            else:
                e_units = self.cal_e_units

            self.spect = sp.Spectrum(
                counts=self.spect.counts,
                energies=self.pred_erg,
                e_units=e_units,
                realtime=self.spect.realtime,
                livetime=self.spect.livetime,
                cps=self.spect.cps,
                acq_date=self.spect.acq_date,
                energy_cal=self.ecal_eqn,
                description=self.spect.description,
                label=self.spect.label,
            )
            self.create_graph(fit=False, reset=True)
            self.search = 0
        except Exception as e:
            print("Could not apply calibration")
            print("An error occurred:", str(e))

    def ecal_remove_selected(self):
        if (
            len(self.selected_rows_ecal) > 0
            and self.df_ecal is not None
            and self.df_ecal.shape[0] > 2
        ):
            for row in self.selected_rows_ecal:
                # row is table index
                erg = self.df_ecal.iloc[row][f"Energy ({self.cal_e_units})"]
                val = self.df_ecal.iloc[row]["Centroid"]
                if erg in self.e_vals:
                    self.mean_vals.remove(val)
                    self.e_vals.remove(erg)
                elif erg in self.e_vals_not_fit:
                    self.mean_vals_not_fit.remove(val)
                    self.e_vals_not_fit.remove(erg)
                    if len(self.e_vals_not_fit) == 0:  # if empty, reset flag
                        self.flag_e_legend = 0
            if len(self.mean_vals) > 1:
                self.update_cal()

    def new_window_cal_add_point(self):
        self.w_cal_addpoint = WindowCalAddPoint()
        self.w_cal_addpoint.show()
        self.w_cal_addpoint.accepted.connect(self.ecal_add_point)

    def ecal_add_point(self):
        try:
            ch_txt = self.w_cal_addpoint.edit_channel.text().split(",")
            erg_txt = self.w_cal_addpoint.edit_energy.text().split(",")
            if len(ch_txt) == len(erg_txt):
                for ch, erg in zip(ch_txt, erg_txt):
                    self.mean_vals.append(eval(ch))
                    self.e_vals.append(eval(erg))
                self.update_cal()
            else:
                print("Channels and energies must be the same length")
        except Exception as e:
            print("Could not add point manually")
            print("An unknown error occurred:", str(e))

    ## efficiency calibration
    def eff_info_activate(self):
        self.w_info_eff.activateWindow()
        self.w_info_eff.show()

    def reset_eff_figure(self):
        self.fig_eff = self.efficiency_plot.canvas.figure
        self.fig_eff.clear()
        self.fig_eff.set_constrained_layout(True)
        gs2 = self.fig_eff.add_gridspec(2, 1, height_ratios=[0.3, 1.5])
        # axes
        self.ax_eff = self.fig_eff.add_subplot(gs2[1, :])
        self.ax_eff_res = self.fig_eff.add_subplot(gs2[0, :], sharex=self.ax_eff)
        # remove ticks
        self.ax_eff.set_xticks([])
        self.ax_eff.set_yticks([])
        self.ax_eff_res.set_xticks([])
        self.ax_eff_res.set_yticks([])

    def reset_eff_all(self):
        self.reset_eff_figure()
        self.fig_eff.canvas.draw_idle()
        self.eff_vals = []
        self.df_eff = None
        try:
            self.table_eff.setParent(None)
        except Exception as e:
            print("Cannot reset table")
            print(str(e))

    def new_window_eff(self):
        self.w_eff = WindowEff()
        self.w_eff.show()
        self.w_eff.accepted.connect(self.add_eff)

    def add_eff(self):
        try:
            self.get_eff_input()
            self.eff_obj = efficiency.Efficiency(
                t_half=self.t_half,
                A0=self.A0,
                Br=self.B,
                livetime=self.acq_time,
                t_elapsed=self.delta_t_sec,
                which_peak=self.n_peak_eff,
            )
            self.eff_obj.calculate_efficiency(self.fit)
            self.eff_obj.calculate_error(
                self.fit,
                self.t_half_sig,
                self.A0_sig,
                self.B_sig,
                self.delta_t_sig,
                self.acq_time_sig,
            )

            df = self.eff_obj.to_df(e_units=self.e_units)
            self.concat_df_eff(df)
            self.update_eff_table()
            self.ax_eff_res.clear()
            self.plot_eff_points()
        except Exception as e:
            print("ERROR: could not add efficiency value")
            print(e)

    def plot_eff_points(self):
        if self.df_eff.shape[0] > 0:
            self.ax_eff_res.clear()
            x = self.df_eff[f"Energy ({self.e_units})"]
            y = self.df_eff["Efficiency"] * 100
            y_err = self.df_eff["+/- Efficiency"]
            self.ax_eff.clear()
            # self.ax_eff_res.clear()
            efficiency.plot_points(
                e_vals=x,
                eff_vals=y,
                err_vals=y_err,
                e_units=self.e_units,
                ax=self.ax_eff,
            )
            self.ax_eff_res.tick_params(axis="x", colors="white")
            self.fig_eff.canvas.draw_idle()

    def concat_df_eff(self, df):
        if df is None:
            self.df_eff = df
        else:
            self.df_eff = pd.concat([self.df_eff, df], ignore_index=True)

    def update_eff_table(self):
        self.df_eff.fillna(value=0, inplace=True)
        self.df_eff.sort_values(
            by=[f"Energy ({self.e_units})"], inplace=True, ignore_index=True
        )
        self.df_eff = self.df_eff.round(6)
        self.df_eff.drop_duplicates(
            subset=[f"Energy ({self.e_units})"], inplace=True, ignore_index=True
        )
        self.activate_eff_table(data=self.df_eff)

    def activate_eff_table(self, data):
        self.selected_rows_eff = []
        self.selected_indexes_eff = []
        self.table_eff = QtWidgets.QTableView()
        self.table_eff.setAlternatingRowColors(True)
        self.table_eff.setSortingEnabled(False)
        stylesheet_header = "::section{Background-color:lightgreen}"
        self.table_eff.horizontalHeader().setStyleSheet(stylesheet_header)
        self.table_eff.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
        self.table_eff.resizeColumnsToContents()
        self.model_eff = TableModel(data)
        self.table_eff.setModel(self.model_eff)
        self.table_eff_area.setWidget(self.table_eff)
        stylesheet_ix = "::section{Background-color:lightgoldenrodyellow}"
        self.table_eff.setStyleSheet(stylesheet_ix)
        self.table_eff.setColumnWidth(10, 150)
        self.table_eff.setColumnWidth(12, 150)
        self.table_eff.selectionModel().selectionChanged.connect(
            self.on_selectionChanged_eff
        )

    def on_selectionChanged_eff(self, selected, deselected):
        for ix in selected.indexes():
            self.selected_rows_eff.append(ix.row())
        for ix in deselected.indexes():
            try:
                self.selected_rows_eff.remove(ix.row())
            except ValueError:
                pass
        self.selected_rows_eff = list(set(self.selected_rows_eff))
        self.selected_indexes_eff = list(
            self.model_eff._data.index[self.selected_rows_eff]
        )
        print(self.selected_indexes_eff)

    def eff_remove_selected(self):
        if len(self.selected_indexes_eff) > 0 and self.df_eff is not None:
            self.df_eff = self.df_eff.drop(self.selected_indexes_eff)
            self.df_eff.reset_index(drop=True, inplace=True)
            self.update_eff_table()
            self.plot_eff_points()
            self.button_fit1_eff.setChecked(False)
            self.button_fit2_eff.setChecked(False)

    def eff_fit1(self):
        if self.button_fit2_eff.isChecked():
            self.button_fit2_eff.setChecked(False)
            self.plot_eff_points()
        if self.df_eff is not None and self.button_fit1_eff.isChecked():
            if self.df_eff.shape[0] > 1:
                x = self.df_eff[f"Energy ({self.e_units})"]
                y = self.df_eff["Efficiency"] * 100
                y_err = self.df_eff["+/- Efficiency"]
                # self.ax_eff.clear()
                efficiency.eff_fit(
                    x, y, y_err, order=1, ax_fit=self.ax_eff, ax_res=self.ax_eff_res
                )
                self.ax_eff.set_xlabel(self.fit.x_units)
                self.ax_eff.set_ylabel("Efficiency [%]")
                self.fig_eff.canvas.draw_idle()
        elif self.df_eff is not None and not self.button_fit1_eff.isChecked():
            self.plot_eff_points()

    def eff_fit2(self):  # TODO
        if self.button_fit1_eff.isChecked():
            self.button_fit1_eff.setChecked(False)
            self.plot_eff_points()
        if self.df_eff is not None and self.button_fit2_eff.isChecked():
            if self.df_eff.shape[0] > 3:
                x = self.df_eff[f"Energy ({self.e_units})"]
                y = self.df_eff["Efficiency"] * 100
                y_err = self.df_eff["+/- Efficiency"]
                # self.ax_eff.clear()
                efficiency.eff_fit(
                    x, y, y_err, order=2, ax_fit=self.ax_eff, ax_res=self.ax_eff_res
                )
                self.ax_eff.set_xlabel(self.fit.x_units)
                self.ax_eff.set_ylabel("Efficiency [%]")
                self.fig_eff.canvas.draw_idle()
        elif self.df_eff is not None and not self.button_fit2_eff.isChecked():
            self.plot_eff_points()

    def eff_yscale(self):
        if self.eff_scale == "log":
            self.ax_eff.set_yscale("linear")
            self.eff_scale = "linear"
        else:
            self.ax_eff.set_yscale("log")
            self.eff_scale = "log"
        self.fig_eff.canvas.draw_idle()

    def get_eff_input(self):
        # which peak?
        if self.w_eff.button_first.isChecked():
            self.n_peak_eff = 0
        elif self.w_eff.button_second.isChecked():
            self.n_peak_eff = 1
        elif self.w_eff.button_third.isChecked():
            self.n_peak_eff = 2

        # t_half
        if self.w_eff.button_seconds.isChecked():
            t_fact = 1
        elif self.w_eff.button_minutes.isChecked():
            t_fact = 60
        elif self.w_eff.button_years.isChecked():
            t_fact = 365 * 24 * 3600
        else:
            msg = "ERROR: time units not determined"
            print(msg)
        self.t_half = float(self.w_eff.txt_t_half.text()) * t_fact
        # t_half sigma
        self.t_half_sig = float(self.w_eff.txt_t_half_sig.text())

        # A0
        if self.w_eff.button_Ci.isChecked():
            A_fact = 3.7e10
        elif self.w_eff.button_Bq.isChecked():
            A_fact = 1
        else:
            msg = "ERROR: activity units not determined"
            print(msg)
        self.A0 = float(self.w_eff.txt_activity.text()) * A_fact
        # A0 sigma
        self.A0_sig = float(self.w_eff.txt_activity_sig.text())

        # dates or time since production
        date_str0 = self.w_eff.txt_init_date.text()
        t_duration = self.w_eff.txt_t_duration.text()
        if date_str0 != " ":
            fmt_str = "%Y-%m-%d"
            date0 = datetime.datetime.strptime(date_str0, fmt_str)
            date_str1 = self.w_eff.txt_end_date.text()
            date1 = datetime.datetime.strptime(date_str1, fmt_str)
            delta_t = date1 - date0
            self.delta_t_sec = delta_t.days * 24 * 3600
        elif t_duration != " ":
            self.delta_t_sec = float(t_duration)
        else:
            msg = "ERROR: either dates or time since production must be specified"
            print(msg)
        self.delta_t_sig = float(self.w_eff.txt_t_duration_sig.text())

        # branching ratio
        self.B = float(self.w_eff.txt_B.text())
        self.B_sig = float(self.w_eff.txt_B_sig.text())

        # acquisition time
        self.acq_time = float(self.w_eff.txt_acq.text())
        self.acq_time_sig = float(self.w_eff.txt_acq_sig.text())

    ## Resolution (FWHM)
    def reset_fwhm_figure(self):
        self.fig_fwhm = self.resolution_plot.canvas.figure
        self.fig_fwhm.clear()
        self.fig_fwhm.set_constrained_layout(True)
        gs = self.fig_fwhm.add_gridspec(
            2, 2, width_ratios=[0.5, 0.5], height_ratios=[0.5, 0.5]
        )

        # axes
        self.ax_fwhm = self.fig_fwhm.add_subplot(gs[:, 0])
        self.ax_fwhm_gauss = self.fig_fwhm.add_subplot(gs[0, 1])
        self.ax_fwhm_tab = self.fig_fwhm.add_subplot(gs[1, 1])

        # remove ticks
        for ax in [self.ax_fwhm, self.ax_fwhm_tab, self.ax_fwhm_gauss]:
            ax.set_xticks([])
            ax.set_yticks([])

        # self.fig.canvas.draw_idle()

    @staticmethod
    def get_fwhm_vals(fit):
        fwhm_lst = []
        for d in fit.peak_info:
            keys = list(d)
            fwhm_val = d[keys[2]]
            fwhm_lst.append(fwhm_val)
        return fwhm_lst

    def which_button_fwhm(self):
        if self.button_fwhm1.isChecked():
            self.n_fwhm = 1
        elif self.button_fwhm2.isChecked():
            self.n_fwhm = 2
        else:
            self.n_fwhm = 1

    def perform_fwhm(self):
        try:
            self.which_button_fwhm()
            self.fwhm_fit = resolution.fwhm_vs_erg(
                energies=self.fwhm_x,
                fwhms=self.fwhm,
                x_units=self.spect.x_units,
                e_units=self.e_units,
                order=self.n_fwhm,
                fig=self.fig_fwhm,
                ax=self.ax_fwhm,
            )
            self.update_table_fwhm()
            self.update_gauss_fwhm()
            self.fig_fwhm.canvas.draw_idle()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def update_table_fwhm(self):
        self.ax_fwhm_tab.clear()
        resolution.fwhm_table(
            x_lst=self.fwhm_x,
            fwhm_lst=self.fwhm,
            e_units=self.e_units,
            ax=self.ax_fwhm_tab,
            fig=self.fig_fwhm,
        )

    def update_gauss_fwhm(self):
        self.ax_fwhm_gauss.clear()
        gauss_comp = pf.GaussianComponents(fit_obj_lst=self.fit_lst)
        gauss_comp.plot_gauss(plot_type="fwhm", fig=self.fig_fwhm, ax=self.ax_fwhm_gauss)

    def add_fwhm(self):
        try:
            self.ax_fwhm.clear()
            xvals = self.get_mean_vals()
            fwhms = self.get_fwhm_vals(self.fit)

            for x, f in zip(xvals, fwhms):
                if x not in self.fwhm_x and f not in self.fwhm:
                    self.fwhm_x.append(x)
                    self.fwhm.append(f)

            self.fit_lst.append(self.fit)
            self.fwhm_x.sort()
            self.fwhm.sort()
            self.perform_fwhm()
            # self.update_fwhm_table()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def update_fwhm_figure(self):
        self.ax_fwhm.clear()
        self.which_button_fwhm()
        self.perform_fwhm()

    def set_origin_fwhm(self):
        self.ax_fwhm.clear()
        if 0 in self.fwhm_x:
            self.fwhm_x.pop(0)
            self.fwhm.pop(0)
        else:
            self.fwhm_x.insert(0, 0)
            self.fwhm.insert(0, 0)

        if len(self.fwhm_x) > 1:
            self.perform_fwhm()
            # self.update_cal_table()

    def reset_fwhm(self):
        print("Reseting calibration")
        self.fit_lst = []
        self.fwhm_x = [0]
        self.fwhm = [0]
        for ax in [self.ax_fwhm, self.ax_fwhm_tab, self.ax_fwhm_gauss]:
            ax.clear()
            # remove ticks
            ax.set_xticks([])
            ax.set_yticks([])
        self.fig_fwhm.canvas.draw_idle()

    def extrapolate_fwhm(self):
        try:
            if self.button_extrapolate.isChecked():
                resolution.fwhm_extrapolate(
                    energies=self.spect.x,
                    fit=self.fwhm_fit,
                    order=self.n_fwhm,
                    ax=self.ax_fwhm,
                    fig=self.fig_fwhm,
                )
                self.fig_fwhm.canvas.draw_idle()
            else:
                self.update_fwhm_figure()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    ## Diagnostics
    def initialize_plots_diagnostics(self):
        self.fig_diag00 = self.diag_plot00.canvas.figure
        self.fig_diag01 = self.diag_plot01.canvas.figure
        self.fig_diag02 = self.diag_plot02.canvas.figure
        self.fig_diag03 = self.diag_plot03.canvas.figure
        self.fig_diag10 = self.diag_plot10.canvas.figure
        self.fig_diag11 = self.diag_plot11.canvas.figure
        self.fig_diag12 = self.diag_plot12.canvas.figure
        self.fig_diag13 = self.diag_plot13.canvas.figure
        self.figs_diag = [
            self.fig_diag00,  # spectrum
            self.fig_diag01,  # counts/cr
            self.fig_diag02,  # measurement times
            self.fig_diag03,  # live time
            self.fig_diag10,  # peak xrange
            self.fig_diag11,  # counts/cr (peak)
            self.fig_diag12,  # centroid/max
            self.fig_diag13,
        ]  # fwhm (%)
        for fig in self.figs_diag:
            fig.clear()
            fig.set_constrained_layout(True)
            fig.patch.set_alpha(0)
        self.ax00 = self.fig_diag00.add_subplot()
        self.ax01 = self.fig_diag01.add_subplot()
        self.ax02 = self.fig_diag02.add_subplot()
        self.ax03 = self.fig_diag03.add_subplot()
        self.ax10 = self.fig_diag10.add_subplot()
        self.ax11 = self.fig_diag11.add_subplot()
        self.ax12 = self.fig_diag12.add_subplot()
        self.ax13 = self.fig_diag13.add_subplot()
        for fig in self.figs_diag:
            fig.canvas.draw_idle()

    def load_diagnostic_data(self):
        self.diag_data = diagnostics.Diagnostics(self.folder_path)
        self.button_cts_cr.setEnabled(True)
        self.button_combine_send.setEnabled(True)

    def change_cts_cr_diag(self):
        if self.flag_tot_cts:
            self.ax01.clear()
            self.diag_data.plot_count_rates(time=False, ax=self.ax01)
            self.fig_diag01.canvas.draw_idle()
            self.flag_tot_cts = False
        else:
            self.ax01.clear()
            self.diag_data.plot_counts(time=False, ax=self.ax01)
            self.flag_tot_cts = True
            self.fig_diag01.canvas.draw_idle()

    def combine_and_send_to_spect(self):
        self.spect = self.diag_data.combine_spects()
        self.e_units = self.spect.e_units
        self.e_units_orig = deepcopy(self.e_units)
        self.spect_orig = deepcopy(self.spect)
        self.create_graph(fit=False, reset=True)
        self.search = 0
        self.setWindowTitle("NASA-gamma: combined spectrum from Diagnostics tab")

    def plot_diagnostic_total(self):
        self.diag_data.plot_spectra(ax=self.ax00)
        self.diag_data.plot_counts(time=False, ax=self.ax01)
        self.diag_data.plot_measurement_times(time=False, ax=self.ax02)
        self.diag_data.plot_livetime_percent(time=False, ax=self.ax03)
        self.flag_tot_cts = True

    def try_fit_peaks_diagnostics(self, integral=False):
        try:
            self.fit_peaks_diagnostics(integral)
            self.button_diag_save.setEnabled(True)
        except Exception as e:
            print("ERROR: Could not perform fit or integral")
            print("An unknown error occurred:", str(e))

    def fit_peaks_diagnostics(self, integral=False):
        self.ax10.clear()
        self.ax11.clear()
        self.ax12.clear()
        self.ax13.clear()
        xmid_txt = self.xmin_diag.text()
        width_txt = self.xmax_diag.text()
        if xmid_txt == "" or width_txt == "":
            print("Must specify X-range bounds")
        elif self.isevaluable(xmid_txt) and self.isevaluable(width_txt):
            xmid = eval(xmid_txt)
            width = eval(width_txt)
        if integral:
            self.diag_data.calculate_integral(xmid=xmid, width=width)
        else:
            self.diag_data.fit_peaks(xmid=xmid, width=width)
        self.diag_data.plot_peaks(ax=self.ax10)
        self.diag_data.plot_fit_counts(time=False, ax=self.ax11)
        self.diag_data.plot_centroid(time=False, ax=self.ax12)
        self.diag_data.plot_fwhm(time=False, ax=self.ax13)
        self.fig_diag10.canvas.draw_idle()
        self.fig_diag11.canvas.draw_idle()
        self.fig_diag12.canvas.draw_idle()
        self.fig_diag13.canvas.draw_idle()
        self.flag_fit_cts = True
        self.flag_centroid = True
        self.button_cts_cr_fit.setEnabled(True)
        self.button_centroid_max.setEnabled(True)

    def change_cts_cr_fit_diag(self):
        if self.flag_fit_cts:
            self.ax11.clear()
            self.diag_data.plot_fit_count_rates(time=False, ax=self.ax11)
            self.fig_diag11.canvas.draw_idle()
            self.flag_fit_cts = False
        else:
            self.ax11.clear()
            self.diag_data.plot_fit_counts(time=False, ax=self.ax11)
            self.flag_fit_cts = True
            self.fig_diag11.canvas.draw_idle()

    def change_centroid_max_diag(self):
        if self.flag_centroid:
            self.ax12.clear()
            self.diag_data.plot_max(time=False, ax=self.ax12)
            self.fig_diag12.canvas.draw_idle()
            self.flag_centroid = False
        else:
            self.ax12.clear()
            self.diag_data.plot_centroid(time=False, ax=self.ax12)
            self.flag_centroid = True
            self.fig_diag12.canvas.draw_idle()

    ## API
    def activate_load_api_file(self):
        try:
            self.load_api_file()
        except Exception as e:
            print("ERROR: Could not load data file")
            print("An unknown error occurred:", str(e))

    def load_api_file(self):
        self.reset_api_figure()
        self.dt_flag = 0
        self.xy_flag = 0
        self.en_flag = 0
        self.raw_flag = 0  # raw data flag
        self.calibrated_flag = 0  # time-shifted and calibrated data flag
        self.sims_flag = 0  # simulations data flag
        filepath = self.api_path_txt.text()
        if filepath == "":
            data_path = None
        else:
            data_path = filepath
        ch_txt = self.api_ch_txt.text()
        date = self.api_date_txt.text()
        runnr = int(self.api_run_txt.text())
        if self.checkBox_exp_raw.isChecked():
            self.raw_flag = 1
            print("Loading experimental data")
        elif self.checkBox_exp_cal.isChecked():
            self.calibrated_flag = 1
            print("Loading experimental data that has been calibrated and time-shifted")
        elif self.checkBox_sims.isChecked():
            self.sims_flag = 1
            print("Loading simulated data")
        if ch_txt == "9":
            ch = 9
            runnr = int(self.api_run_txt.text())
            self.df_api = read_parquet_api.read_parquet_file(
                date, runnr, ch, flood_field=True, data_path=data_path
            )
            FF = True
        else:
            FF = False
            ch = int(ch_txt)
            self.df_api = read_parquet_api.read_parquet_file(
                date=date, runnr=runnr, ch=ch, flood_field=FF, data_path=data_path
            )
            self.df_api["dt"] *= 1e9  # to ns
        self.df_current = self.df_api.copy()
        self.df_previous = self.df_api.copy()
        self.initialize_plots_api(FF)
        self.api_textEdit.setText("")
        try:
            self.read_settings_file(date, runnr, ch, data_path)
        except Exception as e:
            print("ERROR: Settings file not found")
            print(e)

    def read_settings_file(self, date, runnr, ch, data_path):
        tot_time = apicalc.get_total_time(date, runnr, ch, data_path)
        tot_alphas = apicalc.get_total_counts(date, runnr, ch=9, data_path=data_path)
        neutron_yield = apicalc.calculate_neutron_yield(
            date, runnr, ch=9, data_path=data_path
        )
        alphas_txt = f"Total alphas: {tot_alphas:.3E}"
        time_txt = (
            f"Live time (HH:MM:SS): {time.strftime('%H:%M:%S', time.gmtime(tot_time))}"
        )
        nyield_txt = f"Neutron yield (n/s): {neutron_yield:.3E}"
        self.api_textEdit.setText(f"{alphas_txt}\n{time_txt}\n{nyield_txt}")

    def initialize_plots_api(self, flood_field=False):
        if self.sims_flag:
            self.api_xkey = "X"
            self.api_ykey = "Y"
            self.api_ekey = "energy"
            self.trange = [0, 60]
            self.xyplane = (-0.2, 0.2, -0.2, 0.2)
            self.erange_api = [0, self.df_current["energy"].max()]  # in MeV
        elif self.calibrated_flag:
            self.df_current = apicalc.calc_own_pos(self.df_current)
            self.api_xkey = "X2"
            self.api_ykey = "Y2"
            self.api_ekey = "energy"
            self.trange = [-600, 600]  # dt range
            self.xyplane = (-0.9, 0.9, -0.9, 0.9)  # x and y limits
            self.erange_api = [0, self.df_current["energy"].max()]
        elif self.raw_flag:
            self.df_current = apicalc.calc_own_pos(self.df_current)
            self.api_xkey = "X2"
            self.api_ykey = "Y2"
            self.api_ekey = "energy_orig"
            self.trange = [-40, 120]  # dt range
            self.xyplane = (-0.9, 0.9, -0.9, 0.9)  # x and y limits
            self.erange_api = [0, 2**16]  # [0,8]
        else:
            print("ERROR: Cannot determine the data type (raw, calibrated, or simulated)")

        self.ebins = 2**12  # energy bins
        self.hexbins = 80  # x-y bins
        self.tbins = 512  # time bins
        self.colormap = "plasma"
        if flood_field:
            self.plot_xy_api(self.df_current)
        else:
            self.plot_energy_hist_api(self.df_current)
            # self.ax_api_spe.set_yscale(self.api_spect_scale)
            self.plot_time_hist_api(self.df_current)
            self.plot_xy_api(self.df_current)
            self.espan_api()
            self.xyspan_api()
            self.tspan_api()
        self.fig_api.canvas.draw_idle()

    def reset_api_figure(self):
        self.fig_api = self.api_plot.canvas.figure
        self.fig_api.clear()
        self.fig_api.set_constrained_layout(True)
        gs = self.fig_api.add_gridspec(
            2, 2, width_ratios=[0.5, 0.5], height_ratios=[1, 1]
        )

        # axes
        # axcolor = "lightgoldenrodyellow"
        self.ax_api_spe = self.fig_api.add_subplot(gs[0, 0])
        self.ax_api_dt = self.fig_api.add_subplot(gs[1, 0])

        self.ax_api_xy = self.fig_api.add_subplot(gs[:, 1])
        self.api_xy_scale = "linear"
        self.api_button_logxy.setChecked(False)
        self.fig_api.canvas.draw_idle()  # to delete

    def reset_button_api(self):
        try:
            self.reset_api_figure()
            self.dt_flag = 0
            self.xy_flag = 0
            self.en_flag = 0
            self.df_current = self.df_api.copy()
            self.df_previous = self.df_api.copy()
            self.initialize_plots_api()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def send_to_spect_api(self):
        try:
            self.reset_spect_params()
            if self.sims_flag or self.calibrated_flag:
                self.e_units = "Mev"
                self.spect = sp.Spectrum(
                    counts=self.api_gam, energies=self.api_gam_x, e_units=self.e_units
                )
            else:
                self.spect = sp.Spectrum(counts=self.api_gam)
                self.e_units = "channels"
            self.e_units_orig = deepcopy(self.e_units)
            self.spect_orig = deepcopy(self.spect)
            self.create_graph(fit=False, reset=True)
            self.search = 0
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def plot_energy_hist_api(self, df):
        self.api_gam, self.api_edg = np.histogram(
            df[self.api_ekey], bins=self.ebins, range=self.erange_api
        )
        self.api_gam_x = (self.api_edg[1:] + self.api_edg[:-1]) / 2
        self.ax_api_spe.plot(self.api_gam_x, self.api_gam, color="green")
        self.ax_api_spe.set_yscale(self.api_spect_scale)
        if self.sims_flag or self.calibrated_flag:
            self.ax_api_spe.set_xlabel("Energy (Mev)")
        else:
            self.ax_api_spe.set_xlabel("Channels")

    def plot_time_hist_api(self, df):
        if "channel" in list(df.columns):
            if self.api_ch_txt.text() == "7":
                self.trange = [200, 600]
        df["dt"].plot.hist(
            bins=self.tbins,
            ax=self.ax_api_dt,
            range=self.trange,
            alpha=0.7,
            edgecolor="black",
        )
        self.ax_api_dt.set_xlabel("dt (ns)")

    def plot_xy_api(self, df, cbar=True, logxy=False, **kwargs):
        if logxy:
            kwargs["bins"] = "log"
        df.plot.hexbin(
            x=self.api_xkey,
            y=self.api_ykey,
            gridsize=self.hexbins,
            cmap=self.colormap,
            ax=self.ax_api_xy,
            colorbar=cbar,
            extent=self.xyplane,
            title=f"Total counts = {df.shape[0]}",
            **kwargs,
        )
        self.fig_api.canvas.draw_idle()

    def api_xylog(self):
        try:
            if self.api_xy_scale == "linear":
                self.plot_xy_api(self.df_current, cbar=False, logxy=True)
                self.api_xy_scale = "log"
            elif self.api_xy_scale == "log":
                self.plot_xy_api(self.df_current, cbar=False, logxy=False)
                self.api_xy_scale = "linear"
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def api_on_returnXY(self):
        try:
            self.vmax = int(self.api_vmax_txt.text())
            self.plot_xy_api(self.df_current, cbar=False, logxy=False, vmax=self.vmax)
            self.api_xy_scale = "linear"
            self.api_button_logxy.setChecked(False)
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def api_spect_yscale(self):
        try:
            if self.api_spect_scale == "log":
                self.ax_api_spe.set_yscale("linear")
                self.api_spect_scale = "linear"
            else:
                self.ax_api_spe.set_yscale("log")
                self.api_spect_scale = "log"
            self.fig_api.canvas.draw_idle()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def api_window_filters(self):
        self.w_api_filt = WindowAPIfilters()
        self.w_api_filt.show()
        try:
            self.w_api_filt.button_api_apply.clicked.connect(self.apply_api_filters)
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def apply_api_filters(self):
        # Add vertical lines in plot indicating filter values
        xmin_txt = self.w_api_filt.xmin_txt.text()
        xmax_txt = self.w_api_filt.xmax_txt.text()
        ymin_txt = self.w_api_filt.ymin_txt.text()
        ymax_txt = self.w_api_filt.ymax_txt.text()
        tmin_txt = self.w_api_filt.tmin_txt.text()
        tmax_txt = self.w_api_filt.tmax_txt.text()
        emin_txt = self.w_api_filt.emin_txt.text()
        emax_txt = self.w_api_filt.emax_txt.text()
        if (
            (xmin_txt != "")
            and (xmax_txt != "")
            and (ymin_txt != "")
            and (ymax_txt != "")
        ):
            xmin = float(xmin_txt)
            xmax = float(xmax_txt)
            ymin = float(ymin_txt)
            ymax = float(ymax_txt)
            self.apply_xy_filter(xmin, xmax, ymin, ymax)
        if (tmin_txt != "") and (tmax_txt != ""):
            tmin = float(tmin_txt)
            tmax = float(tmax_txt)
            self.apply_t_filter(tmin, tmax)
        if (emin_txt != "") and (emax_txt != ""):
            emin = int(emin_txt)
            emax = int(emax_txt)
            self.apply_energy_filter(emin, emax)

    def espan_api(self):
        self.span_api = SpanSelector(
            self.ax_api_spe,
            self.enselect_api,
            "horizontal",
            useblit=True,
            interactive=True,
            props=dict(alpha=0.3, facecolor="yellow"),
        )

    def enselect_api(self, xmin, xmax):
        xmin = round(xmin, 4)
        xmax = round(xmax, 4)
        print("xmin: ", xmin)
        print("xmax: ", xmax)
        self.apply_energy_filter(xmin, xmax)

    def apply_energy_filter(self, xmin, xmax):
        self.ax_api_dt.clear()
        self.ax_api_xy.clear()
        if self.en_flag == 0:  # energy filter has not been used before
            # elim = (self.df_current["energy_orig"] > self.api_edg[idxmin]) & (
            #     self.df_current["energy_orig"] < self.api_edg[idxmax]
            # )
            elim = (self.df_current[self.api_ekey] > xmin) & (
                self.df_current[self.api_ekey] < xmax
            )
            self.df_previous = self.df_current.copy()
            self.df_current = self.df_current[elim]
            self.en_flag = 1  # set energy filter to used
        else:
            # elim = (self.df_previous["energy_orig"] > self.api_edg[idxmin]) & (
            #     self.df_previous["energy_orig"] < self.api_edg[idxmax]
            # )
            elim = (self.df_previous[self.api_ekey] > xmin) & (
                self.df_previous[self.api_ekey] < xmax
            )
            self.df_current = self.df_previous[elim]
        self.df_current.reset_index(drop=True, inplace=True)
        self.plot_time_hist_api(df=self.df_current)
        self.plot_xy_api(self.df_current, cbar=False)
        # self.span_api.update()
        self.fig_api.canvas.draw_idle()
        #     tspan.update()

    def xyspan_api(self):
        # drawtype is 'box' or 'line' or 'none'
        self.toggle_selector = RectangleSelector(
            self.ax_api_xy,
            self.xyselect_api,
            useblit=True,
            button=[1, 3],  # don't use middle button
            minspanx=0,
            minspany=0,
            spancoords="pixels",
            interactive=True,
            props=dict(facecolor="white", edgecolor="black", alpha=0.1, fill=True),
        )

    def xyselect_api(self, eclick, erelease):
        "eclick and erelease are the press and release events"
        x1, y1 = eclick.xdata, eclick.ydata
        x2, y2 = erelease.xdata, erelease.ydata
        print("(%3.2f, %3.2f) --> (%3.2f, %3.2f)" % (x1, y1, x2, y2))
        # print(" The button you used were: %s %s" % (eclick.button, erelease.button))
        self.apply_xy_filter(x1, x2, y1, y2)

    def apply_xy_filter(self, x1, x2, y1, y2):
        self.ax_api_spe.clear()
        self.ax_api_dt.clear()
        self.ax_api_xy.clear()
        if self.xy_flag == 0:  # xy filter not used before
            xlim = (self.df_current[self.api_xkey] > x1) & (
                self.df_current[self.api_xkey] < x2
            )
            ylim = (self.df_current[self.api_ykey] > y1) & (
                self.df_current[self.api_ykey] < y2
            )
            self.df_previous = self.df_current.copy()
            self.df_current = self.df_current[xlim & ylim]
            self.xy_flag = 1  # set energy filter to used
        else:
            xlim = (self.df_previous[self.api_xkey] > x1) & (
                self.df_previous[self.api_xkey] < x2
            )
            ylim = (self.df_previous[self.api_ykey] > y1) & (
                self.df_previous[self.api_ykey] < y2
            )
            self.df_current = self.df_previous[xlim & ylim]
        self.df_current.fillna(0)
        self.df_current.reset_index(drop=True, inplace=True)
        self.plot_energy_hist_api(df=self.df_current)
        self.plot_time_hist_api(df=self.df_current)
        self.plot_xy_api(df=self.df_previous, cbar=False)
        # self.toggle_selector.update()
        self.fig_api.canvas.draw_idle()

    def tspan_api(self):
        self.tspan = SpanSelector(
            self.ax_api_dt,
            self.tselect_api,
            "horizontal",
            useblit=True,
            interactive=True,
            props=dict(alpha=0.4, facecolor="yellow"),
        )

    def tselect_api(self, tmin, tmax):
        print("tmin: ", round(tmin, 3))
        print("tmax: ", round(tmax, 3))
        self.apply_t_filter(tmin, tmax)

    def apply_t_filter(self, tmin, tmax):
        self.ax_api_spe.clear()
        self.ax_api_xy.clear()
        if self.dt_flag == 0:
            tlim = (self.df_current["dt"] > tmin) & (self.df_current["dt"] < tmax)
            self.df_previous = self.df_current.copy()
            self.df_current = self.df_current[tlim]
            self.dt_flag = 1
        else:
            tlim = (self.df_previous["dt"] > tmin) & (self.df_previous["dt"] < tmax)
            self.df_current = self.df_previous[tlim]
        self.df_current.reset_index(drop=True, inplace=True)
        self.plot_energy_hist_api(df=self.df_current)
        self.plot_xy_api(self.df_current, cbar=False)
        self.fig_api.canvas.draw_idle()
        # espan.update()
        # tspan.update()

    # API MCA
    ##TODO
    def open_api_mca(self):
        self.w_api_mca.activateWindow()
        self.w_api_mca.show()

    def activate_api_mca(self):
        try:
            self.load_api_mca()
        except Exception as e:
            print("ERROR: Could not load MCA file")
            print("An unknown error occurred:", str(e))

    def load_api_mca(self):
        self.initialize_plot_api_mca_all()
        date = self.w_api_mca.edit_date.text()
        runnr = int(self.w_api_mca.edit_run.text())
        print(date)
        print(runnr)
        self.mca_data = helper_api.read_mca(date=date, runnr=runnr)
        self.create_plot_mca_all()

    def initialize_plot_api_mca_all(self):
        self.fig_mca_all = self.w_api_mca.plot_mca_all.canvas.figure
        self.fig_mca_all.clear()
        self.fig_mca_all.set_constrained_layout(True)
        self.fig_mca_all.patch.set_alpha(0)
        self.ax_mca_all = self.fig_mca_all.add_subplot()
        self.fig_mca_all.canvas.draw_idle()
        plt.rcParams.update({"font.size": 18})

    def create_plot_mca_all(self):
        for i, row in enumerate(self.mca_data):
            self.ax_mca_all.plot(row, label=f"Spectrum #{i}")
        self.ax_mca_all.legend()
        self.ax_mca_all.set_xlabel("Channels")
        self.ax_mca_all.set_yscale("log")
        self.fig_mca_all.canvas.draw_idle()

    def activate_api_mca_select(self):
        try:
            self.load_api_mca_select()
        except Exception as e:
            print("ERROR: Could not obtain selected spectrum")
            print("An unknown error occurred:", str(e))

    def load_api_mca_select(self):
        self.initialize_plot_api_mca_select()
        self.spec_no = int(self.w_api_mca.edit_select.text())
        self.mca_data_select = self.mca_data[self.spec_no]
        self.create_plot_mca_select()

    def initialize_plot_api_mca_select(self):
        self.fig_mca_select = self.w_api_mca.plot_mca_select.canvas.figure
        self.fig_mca_select.clear()
        self.fig_mca_select.set_constrained_layout(True)
        self.fig_mca_select.patch.set_alpha(0)
        self.ax_mca_select = self.fig_mca_select.add_subplot()
        self.fig_mca_select.canvas.draw_idle()
        plt.rcParams.update({"font.size": 18})

    def create_plot_mca_select(self):
        self.ax_mca_select.plot(self.mca_data_select, label=f"Spectrum #{self.spec_no}")
        self.ax_mca_select.set_xlabel("Channels")
        self.ax_mca_select.legend()
        self.ax_mca_select.set_yscale("log")
        self.fig_mca_select.canvas.draw_idle()

    def reset_mca_plots(self):
        try:
            self.ax_mca_all.clear()
            self.ax_mca_select.clear()
            self.fig_mca_all.canvas.draw_idle()
            self.fig_mca_select.canvas.draw_idle()
        except Exception as e:
            print("ERROR: Could not reset MCA plots")
            print("An unknown error occurred:", str(e))

    def send_to_spect_mca(self):
        try:
            self.reset_spect_params()
            self.spect = sp.Spectrum(counts=self.mca_data_select)
            self.e_units = "channels"
            self.e_units_orig = deepcopy(self.e_units)
            self.spect_orig = deepcopy(self.spect)
            self.create_graph(fit=False, reset=True)
            self.search = 0
        except Exception as e:
            print("ERROR: Could not send to Spectrum tab")
            print("An unknown error occurred:", str(e))

    # API 3D plot
    def open_api_3D(self):
        self.w_api_3D = WindowAPI3D()
        self.w_api_3D.activateWindow()
        self.w_api_3D.show()
        try:
            self.w_api_3D.button_api_plot3D.clicked.connect(self.create_plot_api3D)
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def create_plot_api3D(self):
        try:
            self.df_current
        except Exception as e:
            print("Make sure you load an API file on the previous window.", str(e))
        if self.sims_flag:
            X, Y, Z = self.df_current["X"], self.df_current["Y"], self.df_current["Z"]
        else:
            X, Y, Z = apicalc.api_xyz(
                df=self.df_current, det_pos=[0, 22.2, -25.515], use_det=False
            )

        # Define the number of bins for the histogram
        num_bins = int(self.w_api_3D.no_bins.text())
        iso_min = float(self.w_api_3D.isomin.text())
        iso_max = float(self.w_api_3D.isomax.text())
        opacity = float(self.w_api_3D.opacity.text())
        surfcount = int(self.w_api_3D.surfcount.text())
        # Compute the 3D histogram
        hist, edges = np.histogramdd((X, Y, Z), bins=num_bins)
        # Compute the bin centers
        x_bin_centers = 0.5 * (edges[0][1:] + edges[0][:-1])
        y_bin_centers = 0.5 * (edges[1][1:] + edges[1][:-1])
        z_bin_centers = 0.5 * (edges[2][1:] + edges[2][:-1])
        # Create a meshgrid of the bin centers
        x_bin_centers, y_bin_centers, z_bin_centers = np.meshgrid(
            x_bin_centers, y_bin_centers, z_bin_centers, indexing="ij"
        )
        # Flatten the arrays for plotting
        x_flat = x_bin_centers.flatten()
        y_flat = y_bin_centers.flatten()
        z_flat = z_bin_centers.flatten()
        values_flat = hist.flatten()
        # Normalize the histogram values for color mapping
        norm_values = (values_flat - values_flat.min()) / (
            values_flat.max() - values_flat.min()
        )
        vol = ndimage.gaussian_filter(norm_values, 4)
        vol /= vol.max()
        # Create a volume plot
        fig = go.Figure(
            go.Volume(
                x=x_flat,
                y=y_flat,
                z=z_flat,
                value=vol,
                isomin=iso_min,
                isomax=iso_max,
                opacity=opacity,  # Needs to be small to see through all surfaces
                surface_count=surfcount,  # Number of iso-surfaces, more surfaces = more detailed plot
                colorscale="Viridis",
            )
        )
        fig.update_layout(
            scene_xaxis_showticklabels=False,
            scene_yaxis_showticklabels=False,
            scene_zaxis_showticklabels=False,
        )
        self.w_api_3D.browser.setHtml(fig.to_html(include_plotlyjs="cdn"))
        # Render the plot to an HTML file
        html = pio.to_html(fig, full_html=True)
        # Write the HTML to a temporary file and load it in the QWebEngineView
        with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as f:
            f.write(html.encode("utf-8"))
            temp_file_path = f.name
        self.w_api_3D.browser.setUrl(QUrl.fromLocalFile(temp_file_path))

    ## PNG
    # TODO
    def png_info_activate(self):
        self.w_info_png.activateWindow()
        self.w_info_png.show()

    def initialize_plots_png(self):
        self.fig_png_dt = self.plot_dt_png.canvas.figure
        self.fig_png_e = self.plot_e_png.canvas.figure
        self.fig_png_decay = self.plot_decay_png.canvas.figure
        self.fig_png_et = self.plot_EvsT_png.canvas.figure
        self.fig_png_dt.clear()
        self.fig_png_e.clear()
        self.fig_png_decay.clear()
        self.fig_png_et.clear()
        self.fig_png_dt.set_constrained_layout(True)
        self.fig_png_e.set_constrained_layout(True)
        self.fig_png_decay.set_constrained_layout(True)
        self.fig_png_et.set_constrained_layout(True)
        self.fig_png_dt.patch.set_alpha(0)
        self.fig_png_e.patch.set_alpha(0)
        self.fig_png_decay.patch.set_alpha(0)
        self.fig_png_et.patch.set_alpha(0)
        self.ax_png_dt = self.fig_png_dt.add_subplot()
        self.ax_png_e = self.fig_png_e.add_subplot()
        self.ax_png_decay = self.fig_png_decay.add_subplot()
        self.ax_png_et = self.fig_png_et.add_subplot()
        self.fig_png_dt.canvas.draw_idle()
        self.fig_png_e.canvas.draw_idle()
        self.fig_png_decay.canvas.draw_idle()
        self.fig_png_et.canvas.draw_idle()
        plt.rcParams.update({"font.size": 18})

    def load_file_png(self):
        try:
            fname = self.filePath_png.text()
            period = eval(self.period_png.text())
            if self.multiscancheck.isChecked():
                ms = file_reader.ReadMultiScanTlist(fname)
                ms.read_file()
                df_raw = ms.df
            elif self.caencheck.isChecked():
                caen = file_reader.ReadCaenListMode(fname)
                caen.parse_data()
                df_raw = pd.DataFrame()
                df_raw["channel"] = caen.df["channel"]
                df_raw["ts"] = caen.df["ts (ns)"]
            self.png = tlist.Tlist(df_raw, period=period)
            if self.isevaluable(self.tbins_png.text()):
                tbins_png = eval(self.tbins_png.text())
            else:
                tbins_png = 200
            if self.isevaluable(self.ebins_png.text()):
                ebins_png = eval(self.ebins_png.text())
            else:
                ebins_png = 2**12
            if self.pushButton_keep_png.isChecked():
                print("Keeping all figures")
            else:
                print("Resetting all figures")
                self.reset_png_plots()
            self.plot_png_dt()
            self.plot_png_e()
        except Exception as e:
            print("An unknown error occurred:", str(e))
            print(
                """ERROR: Could not load file. Make sure you are using the full
                path and input an integer for the period"""
            )

    def reset_png(self):
        self.initialize_plots_png()
        self.load_file_png()
        self.textBrowser_png.setText("")

    def png_spect_yscale(self):
        try:
            if self.png_spect_scale == "log":
                self.ax_png_e.set_yscale("linear")
                self.png_spect_scale = "linear"
            else:
                self.ax_png_e.set_yscale("log")
                self.png_spect_scale = "log"
            self.fig_png_e.canvas.draw_idle()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def reset_png_plots(self):
        self.ax_png_dt.clear()
        self.ax_png_e.clear()
        self.ax_png_decay.clear()
        self.ax_png_et.clear()

    def plot_png_dt(self):
        if self.pushButton_keep_png.isChecked() is False:
            self.ax_png_dt.clear()
        self.png.plot_time_hist(ax=self.ax_png_dt)
        self.fig_png_dt.canvas.draw_idle()

    def plot_png_e(self):
        if self.pushButton_keep_png.isChecked() is False:
            self.ax_png_e.clear()
        self.png.hist_erg()
        self.png.plot_spect_erg_all(self.png.x, self.png.spect, ax=self.ax_png_e)
        self.ax_png_e.set_yscale(self.png_spect_scale)
        self.fig_png_e.canvas.draw_idle()

    def plot_png_decay(self):
        if self.pushButton_keep_png.isChecked() is False:
            self.ax_png_decay.clear()
        self.png.plot_die_away(ax=self.ax_png_decay)
        self.fig_png_decay.canvas.draw_idle()

    def plot_png_fit_decay(self):
        if self.pushButton_keep_png.isChecked() is False:
            self.ax_png_decay.clear()
        if self.checkBox_single_png.isChecked():
            self.exp_png.fit_single_decay()
        elif self.checkBox_double_png.isChecked():
            self.exp_png.fit_double_decay()
        show_comps = False
        if self.pushButton_fit_comps_png.isChecked():
            show_comps = True
        self.exp_png.plot(ax_fit=self.ax_png_decay, show_components=show_comps)
        self.fig_png_decay.canvas.draw_idle()

    def plot_png_et(self):
        if self.pushButton_keep_png.isChecked() is False:
            self.ax_png_et.clear()
        self.png.plot_time_hist(ax=self.ax_png_et)
        self.fig_png_et.canvas.draw_idle()

    def change_tbins_png(self):
        try:
            tbins = eval(self.tbins_png.text())
            self.png.tbins = tbins
            self.plot_png_dt()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def change_ebins_png(self):
        try:
            ebins = eval(self.ebins_png.text())
            self.png.ebins = ebins
            self.plot_png_e()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def apply_trange_png(self):
        try:
            colors = ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"]
            trange = [eval(self.t0_png.text()), eval(self.t1_png.text())]
            self.png.filter_tdata(trange=trange)
            self.plot_png_e()
            self.png.plot_vlines_t(ax=self.ax_png_dt, color=random.choice(colors))
            self.fig_png_dt.canvas.draw_idle()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def apply_erange_png(self):
        try:
            colors = ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"]
            erange = [eval(self.e0_png.text()), eval(self.e1_png.text())]
            self.png.filter_edata(erange=erange)
            self.plot_png_et()
            self.png.plot_vlines_e(ax=self.ax_png_e, color=random.choice(colors))
            self.fig_png_e.canvas.draw_idle()
            self.fig_png_et.canvas.draw_idle()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def apply_die_away(self):
        try:
            t_start = eval(self.t_start_png.text())
            t_end = eval(self.t_end_png.text())
            self.png.filter_tdata(trange=[t_start, t_end], restore_df=False)
            self.png.hist_time()
            self.plot_png_decay()
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def apply_die_away_fit(self):
        try:
            self.exp_png = decay.Decay_exp(
                x=self.png.xd, y=self.png.yd, yerr=self.png.yerrd
            )
            self.plot_png_fit_decay()
            fit_report = self.exp_png.fit_result.fit_report()
            self.textBrowser_png.setText(fit_report)
        except Exception as e:
            print("An unknown error occurred:", str(e))

    def send_to_spect_png(self):
        try:
            self.reset_spect_params()
            self.spect = sp.Spectrum(counts=self.png.spect)
            self.e_units = "channels"
            self.e_units_orig = deepcopy(self.e_units)
            self.spect_orig = deepcopy(self.spect)
            self.create_graph(fit=False, reset=True)
            self.search = 0
        except Exception as e:
            print("An unknown error occurred:", str(e))

    ## Peak finder
    def peakFind_info_activate(self):
        self.w_peak_find_info.activateWindow()
        self.w_peak_find_info.show()

    def activate_peak_finder(self):
        self.w_peak_find.activateWindow()
        txt = f"Xrange (optional) [{self.e_units}]:"
        self.w_peak_find.label_units.setText(txt)
        self.w_peak_find.show()

    def peakFind_kernel_apply(self):
        # self.ax_main.clear()
        self.fwhm_at_0 = 1
        try:
            if self.w_peak_find.checkBox_km.isChecked():
                method = "km"
            else:
                method = "scipy"
            self.min_snr = float(self.w_peak_find.edit_snr.text())
            self.ref_x = float(self.w_peak_find.edit_ref_ch.text())
            self.ref_fwhm = float(self.w_peak_find.edit_ref_fwhm.text())

            x0 = self.w_peak_find.edit_x0.text()
            x1 = self.w_peak_find.edit_x1.text()
            if x0 and x1:
                self.x0 = float(x0)
                self.x1 = float(x1)
                self.search = ps.PeakSearch(
                    self.spect,
                    self.ref_x,
                    self.ref_fwhm,
                    self.fwhm_at_0,
                    min_snr=self.min_snr,
                    xrange=[self.x0, self.x1],
                    method=method,
                )
            else:
                if method == "km" and len(self.spect.channels) < 9000:
                    self.search = ps.PeakSearch(
                        self.spect,
                        self.ref_x,
                        self.ref_fwhm,
                        self.fwhm_at_0,
                        min_snr=self.min_snr,
                        method=method,
                    )
                elif method == "scipy":
                    self.search = ps.PeakSearch(
                        self.spect,
                        self.ref_x,
                        self.ref_fwhm,
                        self.fwhm_at_0,
                        min_snr=self.min_snr,
                        method=method,
                    )
                else:
                    pass
            if self.w_peak_find.checkBox_SNR.isChecked():
                self.snr_state = "on"
            else:
                self.snr_state = "off"
            self.create_graph(fit=True, reset=True)
        except Exception as e:
            print(
                (
                    "ERROR: non-numeric entry or if more than 9000 channels,"
                    "constrain the range using x0 and x1."
                )
            )
            print("An unknown error occurred:", str(e))
            # self.create_graph(fit=False)

    def peakFind_check_hpge(self):
        self.w_peak_find.edit_snr.setText("5")
        self.w_peak_find.edit_ref_ch.setText("420")
        self.w_peak_find.edit_ref_fwhm.setText("3")

    def peakFind_check_labr(self):
        self.w_peak_find.edit_snr.setText("5")
        self.w_peak_find.edit_ref_ch.setText("420")
        self.w_peak_find.edit_ref_fwhm.setText("12")

    def peakFind_check_nai(self):
        self.w_peak_find.edit_snr.setText("5")
        self.w_peak_find.edit_ref_ch.setText("420")
        self.w_peak_find.edit_ref_fwhm.setText("15")

    def peakFind_check_plastic(self):
        self.w_peak_find.edit_snr.setText("5")
        self.w_peak_find.edit_ref_ch.setText("420")
        self.w_peak_find.edit_ref_fwhm.setText("20")

    ## Isotope ID
    def isotID_info_activate(self):
        self.w_isotID_info.activateWindow()
        self.w_isotID_info.show()

    def activate_isotope_id(self):
        self.w_isot_id.activateWindow()
        self.w_isot_id.show()

    def isotID_apply(self):
        df_files = self.isotID_retrieve_data()
        if len(df_files) == 0:
            print("Cannot retrieve data")
        else:
            df_element = self.isotID_filter_by_element(df_files)
            df_energy = self.isotID_filter_by_energy(df_element)
            self.df_isotID = df_energy
            self.df_isotID = self.df_isotID.round(3)
            self.activate_table_gammas(self.df_isotID)

    def isotID_clear(self):
        "Clear entries, uncheck boxes"
        self.w_isot_id.edit_isot.clear()
        self.w_isot_id.edit_energy.clear()
        self.w_isot_id.edit_erange.clear()
        self.w_isot_id.lab_src.setChecked(False)
        self.w_isot_id.natural_rad.setChecked(False)
        self.w_isot_id.neutron_capt.setChecked(False)
        self.w_isot_id.neutron_talys.setChecked(False)
        self.w_isot_id.neutron_inl_baghdad.setChecked(False)

    @staticmethod
    def join_gamma_files(files):
        # to be deleted
        data = pd.read_csv(files[0])
        if len(files) == 1:
            return data
        else:
            for f in files[1:]:
                df0 = pd.read_csv(f)
                data = pd.concat([data, df0], ignore_index=True)
            data["sort"] = data["Isotope"].str.extract(r"(\d+)", expand=False).astype(int)
            print(data.columns)
            data.sort_values("sort", inplace=True, ascending=True)
            data = data.drop("sort", axis=1)
            data.reset_index(inplace=True, drop=True)
            return data

    def isotID_retrieve_data(self):
        lab_src_file = pkg_resources.resource_filename(
            "nasagamma", "data/Common_lab_sources.csv"
        )
        delay_act_file = pkg_resources.resource_filename(
            "nasagamma", "data/Delayed_activation_IAEA.csv"
        )
        nat_rad_file = pkg_resources.resource_filename(
            "nasagamma", "data/Natural_radiation.csv"
        )
        capt_file = pkg_resources.resource_filename(
            "nasagamma", "data/Capture_CapGam.csv"
        )
        capt_IAEA_file = pkg_resources.resource_filename(
            "nasagamma", "data/Capture_IAEA.csv"
        )
        talys_file = pkg_resources.resource_filename("nasagamma", "data/Talys-14MeV.csv")
        inl_baghdad_file = pkg_resources.resource_filename(
            "nasagamma", "data/Inelastic_Baghdad.csv"
        )
        file = 0
        if self.w_isot_id.lab_src.isChecked():
            file = lab_src_file
        elif self.w_isot_id.delayed_activation.isChecked():
            file = delay_act_file
        elif self.w_isot_id.natural_rad.isChecked():
            file = nat_rad_file
        elif self.w_isot_id.neutron_capt.isChecked():
            file = capt_file
        elif self.w_isot_id.neutron_capt_IAEA.isChecked():
            file = capt_IAEA_file
        elif self.w_isot_id.neutron_talys.isChecked():
            file = talys_file
        elif self.w_isot_id.neutron_inl_baghdad.isChecked():
            file = inl_baghdad_file
        else:
            print("ERROR: Select a database from the menu")
        if file == 0:
            return []
        else:
            data = pd.read_csv(file)
            return data

    def isotID_filter_by_element(self, df):
        elements = self.w_isot_id.edit_isot.text()
        if elements == "":
            return df
        elements_lst = elements.split(",")
        ixs = []  # indices
        for el in elements_lst:
            elm = el.strip(" ").lower()
            isot = re.findall(r"\d+", elm)
            if len(isot) == 0:
                ix = list(
                    df.index[df["Isotope"].str.match(f"(\\d+){elm}(\\b)", case=False)]
                )
                ixs.append(ix)
            else:
                ix = list(df.index[df["Isotope"].str.lower() == elm])
                ixs.append(ix)
        ixs_flat = [item for sublist in ixs for item in sublist]
        ixs_uniq = sorted(list(set(ixs_flat)))
        df = df.iloc[ixs_uniq]
        df.reset_index(inplace=True, drop=True)
        return df

    @staticmethod
    def isevaluable(s):
        "Check if eval(s) is possible"
        try:
            eval(s)
            return True
        except:
            return False

    def isotID_filter_by_energy(self, df):
        energy_txt = self.w_isot_id.edit_energy.text()
        if energy_txt == "" or self.isevaluable(energy_txt) is False:
            return df
        energy = eval(energy_txt)
        erange_txt = self.w_isot_id.edit_erange.text()
        if erange_txt == "" or self.isevaluable(erange_txt) is False:
            erange = 0.01  # keV
        else:
            erange = eval(erange_txt)
        filt = (df["Energy (keV)"] > energy - erange) & (
            df["Energy (keV)"] < energy + erange
        )
        df = df[filt]
        df.reset_index(inplace=True, drop=True)
        return df

    ## list of gamma rays
    def activate_table_gammas(self, data):
        self.selected_rows = []
        self.scroll = self.w_isot_id.scrollArea_gammas
        self.table = QtWidgets.QTableView()
        self.table.setAlternatingRowColors(True)
        self.table.setSortingEnabled(True)
        stylesheet = "::section{Background-color:lightgreen}"
        self.table.horizontalHeader().setStyleSheet(stylesheet)
        self.table.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
        self.model = TableModel(data)
        self.table.setModel(self.model)
        self.scroll.setWidget(self.table)
        # self.setCentralWidget(self.scroll)
        self.table.selectionModel().selectionChanged.connect(self.on_selectionChanged)

    def on_selectionChanged(self, selected, deselected):
        for ix in selected.indexes():
            self.selected_rows.append(ix.row())
        for ix in deselected.indexes():
            try:
                self.selected_rows.remove(ix.row())
            except ValueError:
                pass
        self.selected_rows = list(set(self.selected_rows))
        # print(self.selected_rows)
        self.selected_indexes = list(self.model._data.index[self.selected_rows])
        # print(self.selected_indexes)

    def isotID_getColor(self):
        if self.w_isot_id.button_blue.isChecked():
            return "blue"
        if self.w_isot_id.button_orange.isChecked():
            return "C1"
        if self.w_isot_id.button_green.isChecked():
            return "green"
        if self.w_isot_id.button_red.isChecked():
            return "red"

    def isotID_plot_vlines(self):
        "Plot vertical lines of energies of selected rows"
        if len(self.df_isotID) == 0:  # do nothing if empty
            pass
        else:
            if len(self.selected_rows) == 0:  # do all if none selected
                self.df_isotID_plot = self.df_isotID.copy()
                self.df_isotID_selected = self.df_isotID.copy()
            else:
                self.df_isotID_plot = self.df_isotID.loc[self.selected_indexes]
                self.df_isotID_selected = pd.concat(
                    [self.df_isotID_selected, self.df_isotID_plot], ignore_index=True
                )
                self.df_isotID_plot.drop_duplicates(inplace=True)
                self.df_isotID_selected.drop_duplicates(inplace=True)
            for row in self.df_isotID_plot.index:
                isot0 = self.df_isotID_plot.loc[row, "Isotope"]
                e0 = self.df_isotID_plot.loc[row, "Energy (keV)"]
                sep_checked = self.w_isot_id.checkBox_sep.isChecked()
                dep_checked = self.w_isot_id.checkBox_dep.isChecked()
                compton_edge = self.w_isot_id.checkBox_CE.isChecked()

                photopeak = self.ax_main.axvline(
                    x=e0,
                    color=self.isotID_getColor(),
                    linestyle="-",
                    alpha=0.5,
                    label=f"{isot0} : {round(e0,5)} keV",
                )
                if sep_checked and e0 > 1022:
                    e1 = e0 - 511
                    sep = self.ax_main.axvline(
                        x=e1,
                        color=self.isotID_getColor(),
                        linestyle="--",
                        alpha=0.5,
                        label=f"{isot0} : {round(e1,5)} keV (SEP)",
                    )
                    self.isotID_vlines.append(sep)
                if dep_checked and e0 > 1022:
                    e11 = e0 - 511 * 2
                    dep = self.ax_main.axvline(
                        x=e11,
                        color=self.isotID_getColor(),
                        linestyle="-.",
                        alpha=0.5,
                        label=f"{isot0} : {round(e11,5)} keV (DEP)",
                    )
                    self.isotID_vlines.append(dep)

                if compton_edge:
                    e111 = e0 - e0 / (1 + 2 * e0 / 511)
                    ce = self.ax_main.axvline(
                        x=e111,
                        color=self.isotID_getColor(),
                        linestyle=":",
                        alpha=0.5,
                        label=f"{isot0} : {round(e111,5)} keV (CE)",
                    )
                    self.isotID_vlines.append(ce)

                self.isotID_vlines.append(photopeak)
                if len(self.isotID_vlines) > 300:
                    print("Cannot display more than 300 vertical lines.")
                    break
            if self.w_isot_id.checkBox_labels.isChecked():
                self.ax_main.legend()
            self.fig.canvas.draw_idle()

    def isotID_remove_vlines(self):
        if len(self.isotID_vlines) != 0:
            self.df_isotID_selected = pd.DataFrame()
            for l in self.isotID_vlines:
                l.remove()
            self.isotID_vlines = []
            self.ax_main.legend()
            self.fig.canvas.draw_idle()

    def isotID_textSearch(self):
        element = self.w_isot_id.edit_element_search.text()
        if element == "":
            pass
        else:
            out_text = parse_NIST.isotopic_abundance_str(element)
            self.w_isot_id.text_search.setText(out_text)

    ## Save files
    def saveReport(self):
        options = QFileDialog.Options()
        options |= QFileDialog.DontUseNativeDialog
        fileName, _ = QFileDialog.getSaveFileName(
            self, "Save", "", "All Files (*);;Text Files (*.txt)", options=options
        )
        if fileName and len(self.list_xrange) != 0:
            print("Report file: ", fileName)
            self.save_fit(fileName)

    def save_fit(self, fileName):
        try:
            res = self.fit.fit_result
            report = res.fit_report()
            fn = f"Data_filename: {self.fileName}\n"
            xunits = f"x_units: {self.spect.x_units}\n"
            ROI = f"ROI_start_stop: {self.idxmin_fit}, {self.idxmax_fit}\n"
            npeaks = f"Num_peaks: {len(self.fit.peak_info)}\n"
            bkgd = f"Background_type: {self.bg}\n"
            report2 = fn + xunits + ROI + npeaks + bkgd + "\n" + report

            with open(f"{fileName}", "w") as text_file:
                text_file.write(report2)
        except Exception as e:
            print("Cannot save file with fit info")
            print("An unknown error occurred:", str(e))

    def save_spect(self):
        options = QFileDialog.Options()
        fileName, _ = QFileDialog.getSaveFileName(
            self, "Save", "", "All Files (*);", options=options
        )
        try:
            if fileName[-4:] == ".txt":
                self.spect.to_txt(fileName)
            else:
                self.spect.to_csv(fileName)
            print("Saved file: ", fileName)
        except Exception as e:
            print("Cannot save file")
            print("An unknown error occurred:", str(e))

    def save_ID_peaks(self):
        options = QFileDialog.Options()
        fileName, _ = QFileDialog.getSaveFileName(
            self, "Save", "", "All Files (*);;Text Files (*.txt)", options=options
        )
        try:
            print("Saved file: ", fileName)
            df = self.df_isotID_selected
            if ".csv" in fileName:
                df.to_csv(f"{fileName}", index=False)
            else:
                df.to_csv(f"{fileName}.csv", index=False)
        except Exception as e:
            print("Cannot save file with peak info")
            print("An unknown error occurred:", str(e))

    def save_multiple_spectra(self):
        options = QFileDialog.Options()
        fileName, _ = QFileDialog.getSaveFileName(
            self, "Save", "", "All Files (*);", options=options
        )
        try:
            print("Saved file: ", fileName)
            df = self.diag_data.create_data_frame()
            if ".csv" in fileName:
                df.to_csv(f"{fileName}", index=False)
            else:
                df.to_csv(f"{fileName}.csv", index=False)
        except Exception as e:
            print("ERROR: Cannot save file")
            print("An unknown error occurred:", str(e))

    def try_display_info_file(self):
        try:
            self.display_info_file()
        except Exception as e:
            print("Make sure to load a spectrum file.")
            print("The following error occurred:", str(e))

    def display_info_file(self):
        self.w_info_file = WindowInfoFile()
        self.w_info_file.show()
        tot_cts = self.spect.counts.sum()
        nch = self.spect.counts.shape[0]
        self.w_info_file.label_tc.setText(str(tot_cts))
        self.w_info_file.label_nch.setText(str(nch))
        if self.spect.description is None:
            self.w_info_file.label_descript.setText("N/A")
        else:
            self.w_info_file.label_descript.setText(str(self.spect.description))
        if self.spect.label is None:
            self.w_info_file.label_plot.setText("N/A")
        else:
            self.w_info_file.label_plot.setText(str(self.spect.label))
        if self.spect.livetime is None:
            self.w_info_file.label_lt.setText("N/A")
        else:
            count_rate = tot_cts / self.spect.livetime
            self.w_info_file.label_lt.setText(str(self.spect.livetime))
            self.w_info_file.label_cr.setText(str(count_rate))
        if self.spect.realtime is None:
            self.w_info_file.label_rt.setText("N/A")
        else:
            self.w_info_file.label_rt.setText(str(self.spect.realtime))
        if self.spect.livetime is None or self.spect.realtime is None:
            self.w_info_file.label_dt.setText("N/A")
            self.w_info_file.label_cr.setText("N/A")
        else:
            deadtime = round((1 - self.spect.livetime / self.spect.realtime) * 100, 3)
            self.w_info_file.label_dt.setText(str(deadtime))
        if self.spect.acq_date is None:
            self.w_info_file.label_date.setText("N/A")
        else:
            self.w_info_file.label_date.setText(str(self.spect.acq_date))
        if self.spect.energy_cal is None:
            self.w_info_file.label_energy_cal.setText("N/A")
        else:
            self.w_info_file.label_energy_cal.setText(str(self.spect.energy_cal))

    def reset_spectrum(self):
        try:
            self.reset_spect_params()
            self.e_units = deepcopy(self.e_units_orig)
            self.spect = deepcopy(self.spect_orig)
            self.create_graph(fit=False, reset=True)
        except:
            print("Could not reset file")

    def load_spe_file(self):
        try:
            self.fileName, self.e_units, self.spect = self.open_file()
            self.e_units_orig = deepcopy(self.e_units)
            self.spect_orig = deepcopy(self.spect)
            self.create_graph(fit=False, reset=False)
            self.setWindowTitle(f"NASA-gamma: {self.fileName}")
        except:
            print("File could not be opened")

    def open_folder(self):
        self.folder_path = QFileDialog.getExistingDirectory(self, "Select Folder")
        if self.folder_path:
            print(f"Selected folder path: {self.folder_path}")
        try:
            self.initialize_plots_diagnostics()
            self.load_diagnostic_data()
            self.plot_diagnostic_total()
        except:
            print("Could not open folder")

    def open_file(self):
        options = QFileDialog.Options()
        # options |= QFileDialog.DontUseNativeDialog
        fileName, _ = QFileDialog.getOpenFileName(
            self,
            "Open spectrum file",
            "",
            "All Files (*);;",
            options=options,
        )

        if fileName == "":
            pass
        else:
            try:
                print("Opening file: ", fileName)
                fileName_lc = fileName.lower()
                if fileName_lc[-4:] == ".csv":
                    try:
                        spect = file_reader.read_csv_file(fileName)
                        e_units = spect.e_units
                    except:
                        self.lynxcsv = file_reader.ReadLynxCsv(fileName)
                        spect = self.lynxcsv.spect
                        e_units = spect.e_units

                elif fileName_lc[-4:] == ".cnf":
                    spect = file_reader.read_cnf_to_spect(fileName)
                    e_units = spect.e_units
                elif fileName_lc[-4:] == ".mca":
                    mca = file_reader.ReadMCA(fileName)
                    spect = mca.spect
                    e_units = "channels"
                elif fileName_lc[-4:] == ".spe":
                    spe = file_reader.ReadSPE(fileName)
                    e_units = "channels"
                    spect = spe.spect
                elif fileName_lc[-8:] == ".pha.txt":
                    spect = file_reader.read_multiscan(fileName)
                    e_units = spect.e_units

                elif fileName_lc[-4:] == ".txt" and fileName_lc[-8:] != ".pha.txt":
                    spect = file_reader.read_txt(fileName)
                    e_units = spect.e_units
                else:
                    print("Could not open file")
                    fileName = fileName + " ***INVALID FILE TYPE***"
            except Exception as e:
                print("Could not open file")
                print("An unknown error occurred:", str(e))
        return fileName, e_units, spect


if __name__ == "__main__":
    commands = docopt.docopt(__doc__)
    print(commands)

    # initialize figure
    plt.rc("font", size=14)
    plt.style.use("seaborn-v0_8-darkgrid")

    # initialize app
    app = QApplication([])
    window = NasaGammaApp(commands)
    window.show()
    app.exec_()