PyMUS: A Python based Motor Unit Simulator (Kim & Kim 2018)

 Download zip file 
Help downloading and running models
Accession:239535
PyMUS is a simulation software that allows for integrative investigations on the input-output processing of the motor unit system in a hierarchical manner from a single channel to the entire system behavior. Using PyMUS, a single motoneuron, muscle unit and motor unit can be separately simulated under a wide range of experimental input protocols.
Reference:
1 . Kim H, Kim M (2018) PyMUS: Python-Based Simulation Software for Virtual Experiments on Motor Unit System. Front Neuroinform 12:15 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Neuron or other electrically excitable cell;
Brain Region(s)/Organism:
Cell Type(s): Spinal cord lumbar motor neuron alpha cell; Skeletal muscle cell;
Channel(s): I Calcium; I h; I Potassium; I Sodium; I_AHP;
Gap Junctions:
Receptor(s):
Gene(s):
Transmitter(s):
Simulation Environment: Python;
Model Concept(s): Motor control;
Implementer(s): Kim, Hojeong [hojeong.kim03 at gmail.com]; Kim, Minjung [reddkwl at gmail.com];
Search NeuronDB for information about:  Spinal cord lumbar motor neuron alpha cell; I h; I Sodium; I Calcium; I Potassium; I_AHP;
# -*- coding: utf-8 -*-
"""

PyMUS: Simulator for virtual experiments on motor unit system

Version 2.0

Copyright (C) 2017-Now  Hojeong Kim
Neuromuscular Systems Laboratory
DGIST, Korea

This program is free software: you can redistribute it and/or modify it 
under the terms of the GNU General Public License as published by the Free Software Foundation, 
either version 3 of the License, or any later version.  
This program is distributed in the hope that it will be useful, 
but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.  
You should have received a copy of the GNU General Public License along with this program. 
If not, see <http://www.gnu.org/licenses/>.

Please contact us at hojeong.kim03@gmail.com for any inquiries or questions on this program.

"""

import matplotlib as mpl
mpl.use('qt4Agg')
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import math
import sys
import os
import warnings
import copy
from Motorunit import *
from PyQt4.QtGui import *
from PyQt4.QtCore import *
from ui_Main import Ui_MainWindow as Ui_M
from ui_InitialValue import Ui_InitialValueWindow as Ui_ID
from ui_Oscilloscope import Ui_OscilloscopeWindow as Ui_OD
from ui_Parameter import Ui_ParameterSettingWindow as Ui_PD
from ui_SignalGenerator import Ui_SignalGeneratorWindow as Ui_SGD
from ui_AboutThis import Ui_AboutThisWindow as Ui_AT

# Main Window class
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.PSW = ParameterSettingWindow(self) 
        self.ISW = IntegrationSettingWindow(self)
        self.SGW = SignalGeneratorWindow(self)
        self.OW = OscilloscopeWindow(self)
        self.OSC = Oscilloscope()
        self.ATW = AboutThisWindow()
        self.ModelType = ''
        self.uim = Ui_M()
        self.uim.setupUi(self)
        self.uim.ParamButton.setEnabled(False)
        self.uim.IntegrationSettingButton.setEnabled(False)
        self.uim.InputSignalButton.setEnabled(False)
        self.uim.ScopeButton.setEnabled(False)
        self.uim.RunButton.setEnabled(False)
        self.uim.actionSave.setEnabled(False)      
        self.uim.textEdit.setReadOnly(True)
        
        # GUI operation-function
        self.uim.actionDirOpen.triggered.connect(self.openResultDirectory)
        self.uim.actionSave.triggered.connect(self.saveToFile)
        self.uim.actionModel_Information.connect(self.uim.actionModel_Information, SIGNAL("triggered()"), self.openModelInfo)
        self.uim.actionModel_Information.triggered.connect(self.openModelInfo)
        self.uim.actionAboutThis.connect(self.uim.actionAboutThis, SIGNAL("triggered()"), self.openAboutThisWindow)
        self.uim.model_comboBox.connect(self.uim.model_comboBox, SIGNAL('activated(QString)'), self.importModel)
        self.uim.InputSignalButton.clicked.connect(self.openInputSignalWindow)
        self.uim.ParamButton.clicked.connect(self.openParameterWindow)
        self.uim.IntegrationSettingButton.clicked.connect(self.openIntegrationWindow)
        self.uim.ScopeButton.clicked.connect(self.openOscilloscopeWindow)
        self.uim.RunButton.clicked.connect(self.runSimulation)
    
    def importModel(self, text):
        # Question box
        if(self.ModelType != ''):
            result = QMessageBox.question(self, 'Confirm Change...', 'Are you sure you want to change the model ?', QMessageBox.Yes| QMessageBox.No)
            if(result == QMessageBox.No):
                if(self.ModelType == 'Motoneuron'):                
                    self.uim.model_comboBox.setCurrentIndex(1)
                elif(self.ModelType == 'Muscle Fibers'):
                    self.uim.model_comboBox.setCurrentIndex(2)
                elif(self.ModelType == 'Motor Unit'):
                    self.uim.model_comboBox.setCurrentIndex(3)
                return
        
        self.ModelType = text
        # No model
        if(self.ModelType == 'Please Select !'):
            self.ModelType = ''
            self.delete()
            self.uim.ParamButton.setEnabled(False)
            self.uim.IntegrationSettingButton.setEnabled(False)
            self.uim.InputSignalButton.setEnabled(False)
            self.uim.ScopeButton.setEnabled(False)
            self.uim.RunButton.setEnabled(False)
            self.uim.RunButton.setStyleSheet("alternate-background-color: rgb(0, 0, 0)")
            self.uim.actionSave.setEnabled(False)
            self.ATW = AboutThisWindow()
            self.uim.textEdit.clear()
            self.setTextEdit("No Model selected.")
        # MN, MF, NU model
        else:
            self.delete()
            self.uim.ParamButton.setEnabled(True)
            self.uim.IntegrationSettingButton.setEnabled(True)
            self.uim.InputSignalButton.setEnabled(True)
            self.uim.ScopeButton.setEnabled(True)
            self.uim.ScopeButton.setEnabled(True)
            self.uim.RunButton.setEnabled(True)
            self.uim.RunButton.setStyleSheet("background-color: rgb(155, 255, 172)")
            self.uim.actionSave.setEnabled(False)
            self.OSC = Oscilloscope()
            self.ISW = IntegrationSettingWindow(self)        
            self.PSW = ParameterSettingWindow(self)     
            self.OW = OscilloscopeWindow(self) 
            self.SGW = SignalGeneratorWindow(self)
            self.ATW = AboutThisWindow()
            
            # Model creation, default value setting
            if(self.ModelType == 'Motoneuron' or self.ModelType == 'Motor Unit'):
                self.MN = MotoNeuron(1)
                if(self.ModelType == 'Motoneuron'):
                    self.SGW.displayValue()
                    self.MN.setModelParam(self.PSW.mn_setValue, False, False)
                    self.MN.setIntegrationEnv(self.ISW.t_start, self.ISW.t_stop, self.ISW.t_dt, self.ISW.t_pt)
                    self.MN.setInitialValues(self.ISW.mn_setValue)
                    self.MN.setInputSignal(self.SGW.ISG.signalType, self.SGW.ISG.iValue, self.SGW.ISG.pValue, self.SGW.ISG.Is_0, self.SGW.ISG.heav_param)
                    self.MN.setSynConSignal(True, True, True, True, self.SGW.s_SCSG.e_times, self.SGW.s_SCSG.i_times, self.SGW.d_SCSG.e_times, self.SGW.d_SCSG.i_times, self.SGW.s_SCSG.G_e, self.SGW.s_SCSG.G_i, self.SGW.d_SCSG.G_e, self.SGW.d_SCSG.G_i)
                    self.OSC.setModel(self.MN)
            
            if(self.ModelType == 'Muscle Fibers' or self.ModelType == 'Motor Unit'):
                self.MF = MuscleFibers(1)
                if(self.ModelType == 'Muscle Fibers'):
                    self.MF.setModelParam(self.PSW.mf_setValue)
                    self.MF.setIntegrationEnv(self.ISW.t_start, self.ISW.t_stop, self.ISW.t_dt, self.ISW.t_pt)
                    self.MF.setInitialValues(self.ISW.mf_setValue)
                    self.MF.setSpikeSignal(self.SGW.SSG.spike, self.SGW.SSG.spike_idx, self.SGW.SSG.SpikeTimes)
                    self.MF.setXmSignal(self.SGW.XSG.signalType, self.SGW.XSG.times, self.SGW.XSG.xm)
                    self.OSC.setModel(self.MF)
                
                elif(self.ModelType == 'Motor Unit'):
                    self.MU = Motorunit(1, self.MN, self.MF)
                    self.SGW.displayValue()
                    self.MU.setModelParam(self.PSW.mn_setValue, self.PSW.mf_setValue, False, False)
                    self.MU.setIntegrationEnv(self.ISW.t_start, self.ISW.t_stop, self.ISW.t_dt, self.ISW.t_pt)
                    self.MU.setInitialValues(self.ISW.mn_setValue, self.ISW.mf_setValue)
                    self.MU.setInputSignal(self.SGW.ISG.signalType, self.SGW.ISG.iValue, self.SGW.ISG.pValue, self.SGW.ISG.Is_0, self.SGW.ISG.heav_param)
                    self.MU.setSynConSignal(True, True, True, True, self.SGW.s_SCSG.e_times, self.SGW.s_SCSG.i_times, self.SGW.d_SCSG.e_times, self.SGW.d_SCSG.i_times, self.SGW.s_SCSG.G_e, self.SGW.s_SCSG.G_i, self.SGW.d_SCSG.G_e, self.SGW.d_SCSG.G_i)
                    self.MU.setXmSignal(self.SGW.XSG.signalType, self.SGW.XSG.times, self.SGW.XSG.xm)
                    self.OSC.setModel(self.MU)
            self.uim.textEdit.clear()            
            self.setTextEdit("["+self.ModelType+"] Model created.")                    

    def openResultDirectory(self):
        curPath = os.path.dirname( os.path.abspath( sys.argv[0] ) )
        if(sys.platform == 'win32'):
            os.startfile(curPath)
    
    def saveToFile(self):
        curPath = os.path.dirname( os.path.abspath( sys.argv[0] ) )
        t=time.localtime()
        tm_year='{:0>4}'.format(t.tm_year)
        tm_mon='{:0>2}'.format(t.tm_mon)
        tm_mday='{:0>2}'.format(t.tm_mday)
        tm_hour='{:0>2}'.format(t.tm_hour)
        tm_min='{:0>2}'.format(t.tm_min)
        tm_sec='{:0>2}'.format(t.tm_sec)
        timePath='_'+str(tm_year)+str(tm_mon)+str(tm_mday)
        timeName='_'+str(tm_hour)+str(tm_min)+str(tm_sec)

        # file name
        fileName=str(self.OSC.cell.cellType)+timePath+timeName+'.csv'
        filePath = QFileDialog.getSaveFileName(self, "Save Result data in a File. (Must be a csv format)", curPath+'\\'+fileName, "CSV Files (*.csv)")
        if(filePath==''):
            return
            
        # save to file
        if(self.ModelType=="Motoneuron"):            
            df1=pd.DataFrame(self.OSC.mn_ResultArrays)
            cols = ['Time','Is', 'V_soma', '[Ca]_soma','E_Ca_soma','I_Naf_soma','m_Naf_soma','h_Naf_soma','I_Nap_soma','m_Nap_soma','I_Kdr_soma','n_Kdr_soma','I_Kca_soma','I_Can_soma','m_Can_soma','h_Can_soma','I_H_soma','m_H_soma','V_dend','[Ca]_dend','E_Ca_dend','I_Cal_dend','l_Cal_dend','I_Naf_dend','m_Naf_dend','h_Naf_dend','I_Nap_dend','m_Nap_dend','I_Kdr_dend','n_Kdr_dend','I_Kca_dend','I_Can_dend','m_Can_dend','h_Can_dend','I_H_dend','m_H_dend','I_esyn_soma','G_esyn_soma','I_isyn_soma','G_isyn_soma','I_esyn_dend','G_esyn_dend','I_isyn_dend','G_isyn_dend']
        elif(self.ModelType=='Muscle Fibers'):            
            df1=pd.DataFrame(self.OSC.mf_ResultArrays)
            cols = ['Time','F','A','Am','A_tilde','B','CaSP','CaSPB','CaSPT','CaSR','CaSRCS','Cs','R','Spike','T','Vm','XCE','Xm']
        elif(self.ModelType=='Motor Unit'):                
            df1=pd.DataFrame(self.OSC.mu_ResultArrays)
            cols = ['Time','Is', 'V_soma', '[Ca]_soma','E_Ca_soma','I_Naf_soma','m_Naf_soma','h_Naf_soma','I_Nap_soma','m_Nap_soma','I_Kdr_soma','n_Kdr_soma','I_Kca_soma','I_Can_soma','m_Can_soma','h_Can_soma','I_H_soma','m_H_soma','V_dend','[Ca]_dend','E_Ca_dend','I_Cal_dend','l_Cal_dend','I_Naf_dend','m_Naf_dend','h_Naf_dend','I_Nap_dend','m_Nap_dend','I_Kdr_dend','n_Kdr_dend','I_Kca_dend','I_Can_dend','m_Can_dend','h_Can_dend','I_H_dend','m_H_dend','I_esyn_soma','G_esyn_soma','I_isyn_soma','G_isyn_soma','I_esyn_dend','G_esyn_dend','I_isyn_dend','G_isyn_dend','A','Am','A_tilde','B','CaSP','CaSPB','CaSPT','CaSR','CaSRCS','Cs','F','R','Spike','T','Vm','XCE','Xm']
        df = df1.reindex(columns = cols)
        df.to_csv(filePath)
        self.setTextEdit("["+self.ModelType+"] Simulation data saved.")
       
    def openModelInfo(self):
        if(sys.platform == 'win32'):
            os.startfile("model_equations.pdf")
    
    def openAboutThisWindow(self):
        self.ATW.show()
        self.ATW.raise_()
        self.ATW.activateWindow()

    def setTextEdit(self, message):
        cursor = '>>> '
        self.uim.textEdit.append(cursor+message)
    
    def openInputSignalWindow(self):            
        self.SGW.displayValue()
        self.SGW.show()
        self.SGW.raise_()
        self.SGW.activateWindow()

    def runSimulation(self):
        if(self.uim.RunButton.isChecked()):        
            if(self.ModelType == 'Motoneuron'):
                model = self.MN
                scopeList1 = self.OW.mn_ScopeList
                scopeList2 = self.OW.mn_ScopeList
            elif(self.ModelType == 'Muscle Fibers'):
                model = self.MF
                scopeList1 = self.OW.mf_ScopeList
                scopeList2 = self.OW.mf_ScopeList
            elif(self.ModelType == 'Motor Unit'):
                model = self.MU
                scopeList1 = self.OW.mn_ScopeList
                scopeList2 = self.OW.mf_ScopeList
            
            if(self.OW.displayResult == self.OW.uid.radioButton_Individual):
                self.OSC.setScope(list(scopeList1), list(scopeList2), 'Individual')
            elif(self.OW.displayResult == self.OW.uid.radioButton_Combined):
                self.OSC.setScope(list(scopeList1), list(scopeList2), 'Combined')
            
            model.cellState = 'Normal'
            self.uim.model_comboBox.setEnabled(False)
            self.uim.RunButton.setStyleSheet("background-color: rgb(255, 106, 106)")
            self.uim.RunButton.setText("Stop")
            QApplication.processEvents()
            self.setTextEdit("["+self.ModelType+"] Simulation started.")
            
            # run simulation
            try:
                warnings.filterwarnings("error")
                self.OSC.run()
            except:
                self.setTextEdit("[Error] Simulation stopped due to integrator error.")
            finally:
                warnings.filterwarnings("default")
            
            # end simulation
            if(model.cellState != 'Stop'):                    
                self.uim.RunButton.setStyleSheet("background-color: rgb(155, 255, 172)")
                self.uim.RunButton.setText("Run")
                self.uim.RunButton.setChecked(False)
                self.setTextEdit("["+self.ModelType+"] Simulation finished.")
            self.setTextEdit("["+self.ModelType+"] Elapsed real time for simulation: "+str(model.simulTime)+" s")
            self.uim.model_comboBox.setEnabled(True)
            self.uim.actionSave.setEnabled(True)
                
        # stop simulation
        else:
            if(self.ModelType == 'Motoneuron'):
                model = self.MN
            elif(self.ModelType == 'Muscle Fibers'):
                model = self.MF
            elif(self.ModelType == 'Motor Unit'):
                model = self.MU
            model.cellState = 'Stop'
            self.uim.model_comboBox.setEnabled(True)
            self.uim.RunButton.setStyleSheet("background-color: rgb(155, 255, 172)")
            self.uim.RunButton.setText('Run')
            self.setTextEdit("["+self.ModelType+"] Simulation finished.")

    def openParameterWindow(self):
        self.PSW.displayValue()
        self.PSW.show()
        self.PSW.raise_()
        self.PSW.activateWindow()

    def openIntegrationWindow(self):
        self.ISW.displayValue()
        self.ISW.show()
        self.ISW.raise_()
        self.ISW.activateWindow()
    
    def openOscilloscopeWindow(self):
        self.OW.displayScope()
        self.OW.show()
        self.OW.raise_()
        self.OW.activateWindow()
   
    def delete(self):    
        # delete instances
        plt.close('all')
        sys.exc_traceback = sys.last_traceback = None
        if(hasattr(self, 'OSC')):
            del self.OSC
        if(hasattr(self, 'ISW')):
            del self.ISW
        if(hasattr(self, 'PSW')):
            del self.PSW
        if(hasattr(self, 'OW')):
            del self.OW
        if(hasattr(self, 'SGW')):
            del self.SGW
        if(hasattr(self, 'ATW')):
            del self.ATW
        if(hasattr(self, 'MN')):
            del self.MN
        if(hasattr(self, 'MF')):
            del self.MF
        if(hasattr(self, 'MU')):
            del self.MU

    def closeEvent(self, event):
        # Question box
        result = QMessageBox.question(self, 'Confirm Exit...', 'Are you sure you want to exit ?', QMessageBox.Yes| QMessageBox.No)
        event.ignore()

        if(result == QMessageBox.Yes):
            self.delete()
            event.accept()

# About PyMUS information Window class
class AboutThisWindow(QDialog):
    def __init__(self):
        super(AboutThisWindow, self).__init__()
        self.uiat = Ui_AT()
        self.uiat.setupUi(self)
        
# Model Parameter Setting Window class       
class ParameterSettingWindow(QDialog):
    def __init__(self, MW):
        super(ParameterSettingWindow, self).__init__()
        self.MW = MW
        self.init = False
        self.const_sEca = False
        self.const_dEca = False
        # subscript, superscript, Greek letter with unicode and unit label
        alpha = u'\u03B1'
        beta = u'\u03B2'
        gamma = u'\u03B3'
        ohm = u'\u2126'
        mu = u'\u03BC'
        dot = u'\u22C5'
        super_2 = u'\u00B2'
        super_2_p = super_2+u'\u207A'
        super_minus_1 = u'\u207B\u00B9' 
        M_ohm = ' (M'+ohm+')'
        mS_cm_2 = ' (mS/cm'+super_2+')'
        mV = ' (mV)'
        mM = ' (mM)'
        ms_1 = ' (ms'+ super_minus_1+')'
        mol_uC_cm_2 = ' (mol/'+mu+'C/cm'+super_2+')'
        mV_ms_1 = ' (mV'+dot+'ms)'+super_minus_1
        sub_i = u'\u1D62'
        sub_0 = u'\u2080'
        sub_1 = u'\u2081'
        sub_2 = u'\u2082'
        sub_3 = u'\u2083'
        sub_4 = u'\u2084'
        sub_5 = u'\u2085'
        sub_6 = u'\u2086'
        M_1 = ' (M'+super_minus_1+')'
        M_ms_1 = ' (M ms'+super_minus_1+')'
        M_1ms_1 = ' (M'+super_minus_1+'ms'+super_minus_1+')'
        ms_1 = ' (ms'+super_minus_1+')'
        ms = ' (ms)'
        s = ' (s)'
        mm = ' (mm)'
        m_s = ' (m/s)'
        mm_1 = ' (mm'+super_minus_1+')' 
        n = ' (N)'
        mm_s_1 = ' (mm s'+super_minus_1+')'
        tau = u'\u03C4' 
        pi = u'\u03C6'
        
        # subscript with HTML
        sub_N = '<sub>N</sub>'
        sub_m = '<sub>m</sub>'
        sub_SD = '<sub>SD</sub>'
        super_DC = '<sup>DC</sup>'
        sub_DS = '<sub>DS</sub>'
        super_AC = '<sup>AC</sup>'
        sub_Na = '<sub>Na</sub>'
        sub_Naf = '<sub>Naf</sub>'
        sub_Nap = '<sub>Nap</sub>'
        sub_K = '<sub>K</sub>'
        sub_Kdr = '<sub>Kdr</sub>'
        sub_KCa = '<sub>K(Ca)</sub>' 
        sub_Can = '<sub>Can</sub>' 
        sub_H = '<sub>H</sub>' 
        sub_esyn = '<sub>esyn</sub>' 
        sub_isyn = '<sub>isyn</sub>' 
        sub_Cal = '<sub>Cal</sub>'     
        sub_Leak_S = '<sub>Leak,S</sub>'
        sub_Leak_D = '<sub>Leak,D</sub>'
        sub_Ca = '<sub>Ca</sub>'
        sub_d = '<sub>d</sub>'
        sub_o = '<sub>o</sub>'
        sub_max = '<sub>max</sub>'
        K_SE = 'K<sub>SE</sub>'
        sub_axon =  '<sub>axon</sub>'
        
        ## initialization
        # set value
        curPath = os.path.dirname( os.path.abspath( sys.argv[0] ) )
        param = pd.read_csv(curPath + '/parameters/MN_Parameters/MN_Parameters.csv')
        setValue = range(len(param.index))
        for i in range(len(param.index)):
            setValue[i] = float(param.Value[i])
        self.mn_idx = [0, 9, 14, 30, 40, 48, 51, 58, 63, 64, 65, 70, 74, 90, 100, 108, 111, 118, 123, 124, 125]
        self.mn_setValue_num = 125
        iter_num = len(self.mn_idx)
        idx = self.mn_idx
        lstSlice_arr = range(len(self.mn_idx)-1)
        for i in range(1, iter_num):
            lstSlice_arr[i-1] = setValue[idx[i-1]:idx[i]]
        self.mn_setValue = lstSlice_arr
        
        param = pd.read_csv(curPath + '/parameters/MF_Parameters/MF_Parameters.csv')
        setValue = range(len(param.index))
        for i in range(len(param.index)):
            setValue[i] = float(param.Value[i])
        self.mf_idx = [0, 15, 20, 28] 
        self.mf_setValue_num = 28
        iter_num = len(self.mf_idx)
        idx = self.mf_idx
        lstSlice_arr = range(len(self.mf_idx)-1)
        for i in range(1, iter_num):
            lstSlice_arr[i-1] = setValue[idx[i-1]:idx[i]]
        self.mf_setValue = lstSlice_arr
        
        # default value
        self.mn_defaultValue = copy.deepcopy(self.mn_setValue) 
        self.mf_defaultValue = copy.deepcopy(self.mf_setValue)
        
        # previous G
        iter_num = len(self.mn_idx)-1
        idx = self.mn_idx
        k = 0
        self.pre_G = range(len(self.mn_idx)-1)
        for i in range(iter_num):        
            self.pre_G[i] = self.mn_setValue[i][0]  
        
        ## GUI
        self.uid = Ui_PD()
        self.uid.setupUi(self)
        self.mn_tableWidget = [self.uid.tableWidget_share,
                               self.uid.tableWidget_Sca,
                               self.uid.tableWidget_Snaf,
                               self.uid.tableWidget_Snap,
                               self.uid.tableWidget_Skdr,
                               self.uid.tableWidget_Skca,
                               self.uid.tableWidget_Scan,
                               self.uid.tableWidget_Sh,
                               self.uid.tableWidget_Sesyn,
                               self.uid.tableWidget_Sisyn,
                               self.uid.tableWidget_Dca,
                               self.uid.tableWidget_Dcal,
                               self.uid.tableWidget_Dnaf,
                               self.uid.tableWidget_Dnap,
                               self.uid.tableWidget_Dkdr,
                               self.uid.tableWidget_Dkca,
                               self.uid.tableWidget_Dcan,
                               self.uid.tableWidget_Dh,
                               self.uid.tableWidget_Desyn,
                               self.uid.tableWidget_Disyn]                       
        self.mf_tableWidget = [self.uid.tableWidget_m1, 
                               self.uid.tableWidget_m2, 
                               self.uid.tableWidget_m3]
        self.uid.mn_lineEdit.setReadOnly(True)
        self.uid.mf_lineEdit.setReadOnly(True)
        self.channel_enable = {'Snaf' : True,
                               'Snap' : True,
                               'Skdr' : True,
                               'Skca' : True,
                               'Scan' : True,
                               'Sh' : True,
                               'Sesyn' : True,
                               'Sisyn' : True,
                               'Dcal' : True,
                               'Dnaf' : True,
                               'Dnap' : True,
                               'Dkdr' : True,
                               'Dkca' : True,
                               'Dcan' : True,
                               'Dh' : True,
                               'Desyn' : True,
                               'Disyn' : True}
        self.ch_enable_arr = [2,2,True,True,True,True,True,True,2,2,2,True,True,True,True,True,True,True,2,2]
        
        # groupbox label
        self.uid.groupBox_Sca.setTitle('d[Ca' + super_2_p + ']' + sub_i + '/dt  ')
        self.uid.label_Snaf.setText('I' + sub_Naf)
        self.uid.label_Snap.setText('I' + sub_Nap)
        self.uid.label_Skdr.setText('I' + sub_Kdr)
        self.uid.label_Skca.setText('I' + sub_KCa)
        self.uid.label_Scan.setText('I' + sub_Can)
        self.uid.label_Sh.setText('I' + sub_H)
        self.uid.label_Sesyn.setText('I' + sub_esyn)
        self.uid.label_Sisyn.setText('I' + sub_isyn)
        self.uid.groupBox_Dca.setTitle('d[Ca' + super_2_p + ']' + sub_i + '/dt  ')
        self.uid.label_Dcal.setText('I' + sub_Cal)
        self.uid.label_Dnaf.setText('I' + sub_Naf)
        self.uid.label_Dnap.setText('I' + sub_Nap)
        self.uid.label_Dkdr.setText('I' + sub_Kdr)
        self.uid.label_Dkca.setText('I' + sub_KCa)
        self.uid.label_Dcan.setText('I' + sub_Can)
        self.uid.label_Dh.setText('I' + sub_H)
        self.uid.label_Desyn.setText('I' + sub_esyn)
        self.uid.label_Disyn.setText('I' + sub_isyn)
        
        # Parameter label
        mn_parameter_1 = QLabel('R' + sub_N + M_ohm)
        mn_parameter_2 = QLabel(tau + sub_m + s)
        mn_parameter_3 = QLabel('VA' + sub_SD + super_DC)
        mn_parameter_4 = QLabel('VA' + sub_DS + super_DC)
        mn_parameter_5 = QLabel('VA' + sub_SD + super_AC)
        mn_parameter_6 = QLabel('p')
        mn_parameter_7 = QLabel('E' + sub_Leak_S + mV)
        mn_parameter_8 = QLabel('E' + sub_Leak_D + mV)
        mu_parameter = QLabel('CV' + sub_axon + m_s)
        mn_parameter_9 = QLabel('f')
        mn_parameter_10 = QLabel('K' + sub_Ca + ms_1)
        mn_parameter_11 = QLabel(alpha + mol_uC_cm_2)
        mn_parameter_12 = QLabel('[Ca' + super_2_p + ']' + sub_o + mM)
        mn_parameter_126 = QLabel('E' + sub_Ca + mV)
        mn_parameter_13 = QLabel('G' + mS_cm_2)
        mn_parameter_14 = QLabel('E' + sub_Na + mV)
        mn_parameter_15 = QLabel(alpha + sub_1 + mV_ms_1) 
        mn_parameter_16 = QLabel(alpha + sub_2 + mV)
        mn_parameter_17 = QLabel(alpha + sub_3 + mV)
        mn_parameter_18 = QLabel(alpha + sub_4)
        mn_parameter_19 = QLabel(beta + sub_1 + mV_ms_1)
        mn_parameter_20 = QLabel(beta + sub_2 + mV)
        mn_parameter_21 = QLabel(beta + sub_3 + mV)
        mn_parameter_22 = QLabel(beta + sub_4)
        mn_parameter_23 = QLabel(gamma + sub_1 + mV)
        mn_parameter_24 = QLabel(gamma + sub_2 + mV)
        mn_parameter_25 = QLabel(gamma + sub_3 + mV)
        mn_parameter_26 = QLabel(gamma + sub_4 + mV)
        mn_parameter_27 = QLabel(gamma + sub_5 + mV)
        mn_parameter_28 = QLabel(gamma + sub_6 + mV)
        mn_parameter_29 = QLabel('G' + mS_cm_2)
        mn_parameter_30 = QLabel('E' + sub_Na + mV)
        mn_parameter_31 = QLabel(alpha + sub_1 + mV_ms_1)
        mn_parameter_32 = QLabel(alpha + sub_2 + mV)
        mn_parameter_33 = QLabel(alpha + sub_3 + mV)
        mn_parameter_34 = QLabel(alpha + sub_4)
        mn_parameter_35 = QLabel(beta + sub_1 + mV_ms_1)
        mn_parameter_36 = QLabel(beta + sub_2 + mV)
        mn_parameter_37 = QLabel(beta + sub_3 + mV)
        mn_parameter_38 = QLabel(beta + sub_4)  
        mn_parameter_39 = QLabel('G' + mS_cm_2)
        mn_parameter_40 = QLabel('E' + sub_K + mV)
        mn_parameter_41 = QLabel(gamma + sub_1 + mV)
        mn_parameter_42 = QLabel(gamma + sub_2 + mV)
        mn_parameter_43 = QLabel(gamma + sub_3 + mV)
        mn_parameter_44 = QLabel(gamma + sub_4 + mV)
        mn_parameter_45 = QLabel(gamma + sub_5 + mV)
        mn_parameter_46 = QLabel(gamma + sub_6 + ms)
        mn_parameter_47 = QLabel('G' + mS_cm_2)
        mn_parameter_48 = QLabel('E' + sub_K + mV)
        mn_parameter_49 = QLabel('K' + sub_d + mM)  
        mn_parameter_50 = QLabel('G' + mS_cm_2)
        mn_parameter_51 = QLabel(gamma + sub_1 + mV)
        mn_parameter_52 = QLabel(gamma + sub_2 + mV)
        mn_parameter_53 = QLabel(gamma + sub_3 + ms)
        mn_parameter_54 = QLabel(gamma + sub_1 + mV)
        mn_parameter_55 = QLabel(gamma + sub_2 + mV)
        mn_parameter_56 = QLabel(gamma + sub_3 + ms)
        mn_parameter_57 = QLabel('G' + mS_cm_2)
        mn_parameter_58 = QLabel('E' + mV)
        mn_parameter_59 = QLabel(gamma + sub_1 + mV)
        mn_parameter_60 = QLabel(gamma + sub_2 + mV)
        mn_parameter_61 = QLabel(gamma + sub_3 + ms)
        mn_parameter_62 = QLabel('E' + sub_esyn + mV)
        mn_parameter_64 = QLabel('E' + sub_isyn + mV)
        mn_parameter_66 = QLabel('f')
        mn_parameter_67 = QLabel('K' + sub_Ca + ms_1)
        mn_parameter_68 = QLabel(alpha + mol_uC_cm_2)
        mn_parameter_69 = QLabel('[Ca' + super_2_p + ']' + sub_o + mM)
        mn_parameter_127 = QLabel('E' + sub_Ca + mV)
        mn_parameter_70 = QLabel('G' + mS_cm_2)
        mn_parameter_71 = QLabel(gamma + sub_1 + mV)
        mn_parameter_72 = QLabel(gamma + sub_2 + mV)
        mn_parameter_73 = QLabel(gamma + sub_3 + ms)
        mn_parameter_74 = QLabel('G' + mS_cm_2)
        mn_parameter_75 = QLabel('E' + sub_Na + mV)
        mn_parameter_76 = QLabel(alpha + sub_1 + mV_ms_1) 
        mn_parameter_77 = QLabel(alpha + sub_2 + mV)
        mn_parameter_78 = QLabel(alpha + sub_3 + mV)
        mn_parameter_79 = QLabel(alpha + sub_4)
        mn_parameter_80 = QLabel(beta + sub_1 + mV_ms_1)
        mn_parameter_81 = QLabel(beta + sub_2 + mV)
        mn_parameter_82 = QLabel(beta + sub_3 + mV)
        mn_parameter_83 = QLabel(beta + sub_4)
        mn_parameter_84 = QLabel(gamma + sub_1 + mV)
        mn_parameter_85 = QLabel(gamma + sub_2 + mV)
        mn_parameter_86 = QLabel(gamma + sub_3 + mV)
        mn_parameter_87 = QLabel(gamma + sub_4 + mV)
        mn_parameter_88 = QLabel(gamma + sub_5 + mV)
        mn_parameter_89 = QLabel(gamma + sub_6 + mV)
        mn_parameter_90 = QLabel('G' + mS_cm_2)
        mn_parameter_91 = QLabel('E' + sub_Na + mV)
        mn_parameter_92 = QLabel(alpha + sub_1 + mV_ms_1)
        mn_parameter_93 = QLabel(alpha + sub_2 + mV)
        mn_parameter_94 = QLabel(alpha + sub_3 + mV)
        mn_parameter_95 = QLabel(alpha + sub_4)
        mn_parameter_96 = QLabel(beta + sub_1 + mV_ms_1)
        mn_parameter_97 = QLabel(beta + sub_2 + mV)
        mn_parameter_98 = QLabel(beta + sub_3 + mV)
        mn_parameter_99 = QLabel(beta + sub_4)
        mn_parameter_100 = QLabel('G' + mS_cm_2)
        mn_parameter_101 = QLabel('E' + sub_K + mV)
        mn_parameter_102 = QLabel(gamma + sub_1 + mV)
        mn_parameter_103 = QLabel(gamma + sub_2 + mV)
        mn_parameter_104 = QLabel(gamma + sub_3 + mV)
        mn_parameter_105 = QLabel(gamma + sub_4 + mV)
        mn_parameter_106 = QLabel(gamma + sub_5 + mV)
        mn_parameter_107 = QLabel(gamma + sub_6 + ms)
        mn_parameter_108 = QLabel('G' + mS_cm_2)
        mn_parameter_109 = QLabel('E' + sub_K + mV)
        mn_parameter_110 = QLabel('K' + sub_d + mM)
        mn_parameter_111 = QLabel('G' + mS_cm_2)
        mn_parameter_112 = QLabel(gamma + sub_1 + mV)
        mn_parameter_113 = QLabel(gamma + sub_2 + mV)
        mn_parameter_114 = QLabel(gamma + sub_3 + ms)
        mn_parameter_115 = QLabel(gamma + sub_1 + mV)
        mn_parameter_116 = QLabel(gamma + sub_2 + mV)
        mn_parameter_117 = QLabel(gamma + sub_3 + ms)
        mn_parameter_118 = QLabel('G' + mS_cm_2)
        mn_parameter_119 = QLabel('E' + mV)
        mn_parameter_120 = QLabel(gamma + sub_1 + mV)
        mn_parameter_121 = QLabel(gamma + sub_2 + mV)
        mn_parameter_122 = QLabel(gamma + sub_3 + ms)
        mn_parameter_123 = QLabel('E' + sub_esyn + mV)
        mn_parameter_125 = QLabel('E' + sub_isyn + mV)
        mf_parameter_1 = QLabel('K1' + M_1ms_1)
        mf_parameter_2 = QLabel('K2' + ms_1)
        mf_parameter_3 = QLabel('K3' + M_1ms_1)
        mf_parameter_4 = QLabel('K4' + ms_1)
        mf_parameter_5 = QLabel('K5' + M_1ms_1)
        mf_parameter_6 = QLabel('K6' + sub_i + ms_1)
        mf_parameter_7 = QLabel('K' + M_1)
        mf_parameter_8 = QLabel('R' + sub_max + ms_1)
        mf_parameter_9 = QLabel('U' + sub_max + M_ms_1)
        mf_parameter_10 = QLabel(tau + sub_1+ms)
        mf_parameter_11 = QLabel(tau + sub_2+ms)
        mf_parameter_12 = QLabel(pi+sub_1+mm_1)
        mf_parameter_13 = QLabel(pi+sub_2)
        mf_parameter_14 = QLabel(pi+sub_3+mm_1)
        mf_parameter_15 = QLabel(pi+sub_4)        
        mf_parameter_16 = QLabel('C1')
        mf_parameter_17 = QLabel('C2')
        mf_parameter_18 = QLabel('C3' + ms)
        mf_parameter_19 = QLabel('C4')
        mf_parameter_20 = QLabel('C5')
        mf_parameter_21 = QLabel(K_SE + mm_1)
        mf_parameter_22 = QLabel('P'+sub_0+n)
        mf_parameter_23 = QLabel('g'+sub_1+mm)
        mf_parameter_24 = QLabel('g'+sub_2+mm)
        mf_parameter_26 = QLabel('a'+sub_0+n)
        mf_parameter_27 = QLabel('b'+sub_0+mm_s_1)
        mf_parameter_28 = QLabel('c'+sub_0+n)
        mf_parameter_29 = QLabel('d'+sub_0+mm_s_1)

        mn_parameter = []
        mn_parameter.append(mn_parameter_1)
        mn_parameter.append(mn_parameter_2)
        mn_parameter.append(mn_parameter_3)
        mn_parameter.append(mn_parameter_4)
        mn_parameter.append(mn_parameter_5)
        mn_parameter.append(mn_parameter_6)
        mn_parameter.append(mn_parameter_7)
        mn_parameter.append(mn_parameter_8)
        mn_parameter.append(mu_parameter)
        mn_parameter.append(mn_parameter_9)
        mn_parameter.append(mn_parameter_10)
        mn_parameter.append(mn_parameter_11)
        mn_parameter.append(mn_parameter_12)
        mn_parameter.append(mn_parameter_126)
        mn_parameter.append(mn_parameter_13)
        mn_parameter.append(mn_parameter_14)
        mn_parameter.append(mn_parameter_15)
        mn_parameter.append(mn_parameter_16)
        mn_parameter.append(mn_parameter_17)
        mn_parameter.append(mn_parameter_18)
        mn_parameter.append(mn_parameter_19)
        mn_parameter.append(mn_parameter_20)      
        mn_parameter.append(mn_parameter_21)
        mn_parameter.append(mn_parameter_22)
        mn_parameter.append(mn_parameter_23)
        mn_parameter.append(mn_parameter_24)
        mn_parameter.append(mn_parameter_25)
        mn_parameter.append(mn_parameter_26)
        mn_parameter.append(mn_parameter_27)
        mn_parameter.append(mn_parameter_28)
        mn_parameter.append(mn_parameter_29)
        mn_parameter.append(mn_parameter_30)    
        mn_parameter.append(mn_parameter_31)
        mn_parameter.append(mn_parameter_32)
        mn_parameter.append(mn_parameter_33)
        mn_parameter.append(mn_parameter_34)
        mn_parameter.append(mn_parameter_35)
        mn_parameter.append(mn_parameter_36)
        mn_parameter.append(mn_parameter_37)
        mn_parameter.append(mn_parameter_38)
        mn_parameter.append(mn_parameter_39)
        mn_parameter.append(mn_parameter_40)    
        mn_parameter.append(mn_parameter_41)
        mn_parameter.append(mn_parameter_42)
        mn_parameter.append(mn_parameter_43)
        mn_parameter.append(mn_parameter_44)
        mn_parameter.append(mn_parameter_45)
        mn_parameter.append(mn_parameter_46)
        mn_parameter.append(mn_parameter_47)
        mn_parameter.append(mn_parameter_48)
        mn_parameter.append(mn_parameter_49)
        mn_parameter.append(mn_parameter_50)    
        mn_parameter.append(mn_parameter_51)
        mn_parameter.append(mn_parameter_52)
        mn_parameter.append(mn_parameter_53)
        mn_parameter.append(mn_parameter_54)
        mn_parameter.append(mn_parameter_55)
        mn_parameter.append(mn_parameter_56)
        mn_parameter.append(mn_parameter_57)
        mn_parameter.append(mn_parameter_58)
        mn_parameter.append(mn_parameter_59)
        mn_parameter.append(mn_parameter_60) 
        mn_parameter.append(mn_parameter_61)
        mn_parameter.append(mn_parameter_62)
        mn_parameter.append(mn_parameter_64)
        mn_parameter.append(mn_parameter_66)
        mn_parameter.append(mn_parameter_67)
        mn_parameter.append(mn_parameter_68)
        mn_parameter.append(mn_parameter_69)
        mn_parameter.append(mn_parameter_127)
        mn_parameter.append(mn_parameter_70)
        mn_parameter.append(mn_parameter_71)
        mn_parameter.append(mn_parameter_72)
        mn_parameter.append(mn_parameter_73)
        mn_parameter.append(mn_parameter_74)
        mn_parameter.append(mn_parameter_75)
        mn_parameter.append(mn_parameter_76)
        mn_parameter.append(mn_parameter_77)
        mn_parameter.append(mn_parameter_78)
        mn_parameter.append(mn_parameter_79)
        mn_parameter.append(mn_parameter_80)      
        mn_parameter.append(mn_parameter_81)
        mn_parameter.append(mn_parameter_82)
        mn_parameter.append(mn_parameter_83)
        mn_parameter.append(mn_parameter_84)
        mn_parameter.append(mn_parameter_85)
        mn_parameter.append(mn_parameter_86)
        mn_parameter.append(mn_parameter_87)
        mn_parameter.append(mn_parameter_88)
        mn_parameter.append(mn_parameter_89)
        mn_parameter.append(mn_parameter_90)    
        mn_parameter.append(mn_parameter_91)
        mn_parameter.append(mn_parameter_92)
        mn_parameter.append(mn_parameter_93)
        mn_parameter.append(mn_parameter_94)
        mn_parameter.append(mn_parameter_95)
        mn_parameter.append(mn_parameter_96)
        mn_parameter.append(mn_parameter_97)
        mn_parameter.append(mn_parameter_98)
        mn_parameter.append(mn_parameter_99)
        mn_parameter.append(mn_parameter_100)    
        mn_parameter.append(mn_parameter_101)
        mn_parameter.append(mn_parameter_102)
        mn_parameter.append(mn_parameter_103)
        mn_parameter.append(mn_parameter_104)
        mn_parameter.append(mn_parameter_105)
        mn_parameter.append(mn_parameter_106)
        mn_parameter.append(mn_parameter_107)
        mn_parameter.append(mn_parameter_108)
        mn_parameter.append(mn_parameter_109)
        mn_parameter.append(mn_parameter_110)    
        mn_parameter.append(mn_parameter_111)
        mn_parameter.append(mn_parameter_112)
        mn_parameter.append(mn_parameter_113)
        mn_parameter.append(mn_parameter_114)
        mn_parameter.append(mn_parameter_115)
        mn_parameter.append(mn_parameter_116)
        mn_parameter.append(mn_parameter_117)
        mn_parameter.append(mn_parameter_118)
        mn_parameter.append(mn_parameter_119)
        mn_parameter.append(mn_parameter_120)
        mn_parameter.append(mn_parameter_121)
        mn_parameter.append(mn_parameter_122)
        mn_parameter.append(mn_parameter_123)
        mn_parameter.append(mn_parameter_125)
        mf_parameter = []
        mf_parameter.append(mf_parameter_1)
        mf_parameter.append(mf_parameter_2)
        mf_parameter.append(mf_parameter_3)
        mf_parameter.append(mf_parameter_4)
        mf_parameter.append(mf_parameter_5)
        mf_parameter.append(mf_parameter_6)
        mf_parameter.append(mf_parameter_7)
        mf_parameter.append(mf_parameter_8)
        mf_parameter.append(mf_parameter_9)
        mf_parameter.append(mf_parameter_10)
        mf_parameter.append(mf_parameter_11)
        mf_parameter.append(mf_parameter_12)
        mf_parameter.append(mf_parameter_13)
        mf_parameter.append(mf_parameter_14)
        mf_parameter.append(mf_parameter_15)
        mf_parameter.append(mf_parameter_16)
        mf_parameter.append(mf_parameter_17)
        mf_parameter.append(mf_parameter_18)
        mf_parameter.append(mf_parameter_19)
        mf_parameter.append(mf_parameter_20)
        mf_parameter.append(mf_parameter_21)
        mf_parameter.append(mf_parameter_22)
        mf_parameter.append(mf_parameter_23)
        mf_parameter.append(mf_parameter_24)
        mf_parameter.append(mf_parameter_26)
        mf_parameter.append(mf_parameter_27)
        mf_parameter.append(mf_parameter_28)
        mf_parameter.append(mf_parameter_29)

        # tableWidget
        # row, col
        col_num = 3
        iter_num = len(self.mn_setValue)
        for i in range(iter_num):
            self.mn_tableWidget[i].setColumnCount(col_num)
            self.mn_tableWidget[i].setRowCount(len(self.mn_setValue[i]))
        
        iter_num = len(self.mf_setValue)
        for i in range(iter_num):
            self.mf_tableWidget[i].setColumnCount(col_num)
            self.mf_tableWidget[i].setRowCount(len(self.mf_setValue[i]))
        
        # label
        iter_num = len(mn_parameter)
        idx = self.mn_idx
        k = 0
        for i in range(iter_num):
            self.mn_tableWidget[k].setCellWidget(i-idx[k], 0, mn_parameter[i])
            if(i == idx[k+1]-1):
                k+=1
        
        iter_num = len(mf_parameter)
        idx = self.mf_idx
        k = 0
        for i in range(iter_num):
            self.mf_tableWidget[k].setCellWidget(i-idx[k], 0, mf_parameter[i])
            if(i == idx[k+1]-1):
                k+=1
        
        # deactivation cell
        iter_num = len(mn_parameter)
        idx = self.mn_idx
        k = 0
        for i in range(iter_num):
            item = QTableWidgetItem()
            item.setFlags(Qt.ItemIsEnabled)
            self.mn_tableWidget[k].setItem(i-idx[k], 2, item)
            if(i == idx[k+1]-1):
                k+=1
        
        iter_num = len(mf_parameter)
        idx = self.mf_idx
        k = 0
        for i in range(iter_num):
            item = QTableWidgetItem()
            item.setFlags(Qt.ItemIsEnabled)
            self.mf_tableWidget[k].setItem(i-idx[k], 2, item)
            if(i == idx[k+1]-1):
                k+=1
        
        # GUI operation-function      
        self.uid.mn_load_pushButton.clicked.connect(self.openFile)
        self.uid.mf_load_pushButton.clicked.connect(self.openFile)
        self.uid.buttonBox.accepted.connect(self.setValue)
        self.uid.applyButton.clicked.connect(self.setValue)
        self.uid.tableWidget_share.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Sca.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Snaf.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Snap.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Skdr.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Skca.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Scan.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Sh.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Sesyn.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Sisyn.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dca.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dcal.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dnaf.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dnap.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dkdr.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dkca.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dcan.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dh.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Desyn.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Disyn.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_m1.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_m2.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_m3.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_share.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Sca.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Snaf.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Snap.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Skdr.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Skca.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Scan.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Sh.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Sesyn.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Sisyn.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dca.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dcal.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dnaf.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dnap.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dkdr.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dkca.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dcan.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dh.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Desyn.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Disyn.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_m1.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_m2.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_m3.cellChanged.connect(self.checkValue)
        self.uid.checkBox_const_SEca.stateChanged.connect(self.checkValue)
        self.uid.checkBox_const_DEca.stateChanged.connect(self.checkValue)
        
    def keyPressEvent(self, event):
        if(event.key() == 0x01000005 or event.key() == 0x01000004):
            pass
        else:
            # QDialog event
            super(ParameterSettingWindow, self).keyPressEvent(event)

    def checkValue(self, row=3, col=3):
        if(col == 3):
            sub_Ca = '<sub>Ca</sub>'
            mv = ' (mV)'
            row = 4
            l_col = 0
            v_col = 1
            label_1 = QLabel('E' + sub_Ca + mv)
            label_2 = QLabel('E' + sub_Ca + mv)
            act_color = Qt.black
            de_color = Qt.darkGray
            
            # Eca checkBox
            if(self.uid.checkBox_const_SEca.isChecked()):
                self.const_sEca = True
                label_1.setEnabled(True)
                self.MW.SGW.setItemColorEnable(self.uid.tableWidget_Sca, row, v_col, act_color, True)
            else:
                self.const_sEca = False
                label_1.setEnabled(False)
                self.MW.SGW.setItemColorEnable(self.uid.tableWidget_Sca, row, v_col, de_color, False)
            
            if(self.uid.checkBox_const_DEca.isChecked()):
                self.const_dEca = True
                label_2.setEnabled(True)
                self.MW.SGW.setItemColorEnable(self.uid.tableWidget_Dca, row, v_col, act_color, True)
            else:
                self.const_dEca = False
                label_2.setEnabled(False)
                self.MW.SGW.setItemColorEnable(self.uid.tableWidget_Dca, row, v_col, de_color, False)
            self.uid.tableWidget_Sca.setCellWidget(row, l_col, label_1)
            self.uid.tableWidget_Dca.setCellWidget(row, l_col, label_2)
        
        elif(col == 1):
            tableWidget = self.sender()
            
            for i in range(len(self.mn_tableWidget)):
                if(tableWidget == self.mn_tableWidget[i]):
                    item = tableWidget.item(row, col)
                    defValue = self.mn_defaultValue[i][row]
                    setValue = self.mn_setValue[i][row]
                    
                    # opossite reversal potential
                    if(self.init == True and row == 1):
                        if(tableWidget == self.uid.tableWidget_Snaf):
                            op_tablewidget = self.uid.tableWidget_Snap
                        elif(tableWidget == self.uid.tableWidget_Snap):
                            op_tablewidget = self.uid.tableWidget_Snaf
                        elif(tableWidget == self.uid.tableWidget_Skdr):
                            op_tablewidget = self.uid.tableWidget_Skca
                        elif(tableWidget == self.uid.tableWidget_Skca):
                            op_tablewidget = self.uid.tableWidget_Skdr
                        elif(tableWidget == self.uid.tableWidget_Dnaf):
                            op_tablewidget = self.uid.tableWidget_Dnap
                        elif(tableWidget == self.uid.tableWidget_Dnap):
                            op_tablewidget = self.uid.tableWidget_Dnaf
                        elif(tableWidget == self.uid.tableWidget_Dkdr):
                            op_tablewidget = self.uid.tableWidget_Dkca
                        elif(tableWidget == self.uid.tableWidget_Dkca):
                            op_tablewidget = self.uid.tableWidget_Dkdr
                        else:
                            continue
                        thisValue = float(item.text())
                        op_item = op_tablewidget.item(1, 1)
                        opValue = float(op_item.text())
                        if(round(thisValue, 10) != round(opValue, 10)):
                            temp_item = QTableWidgetItem(str(thisValue))
                            op_tablewidget.setItem(1, 1, temp_item)
            
            for i in range(len(self.mf_tableWidget)):
                if(tableWidget == self.mf_tableWidget[i]):
                    item = tableWidget.item(row, col)
                    defValue = self.mf_defaultValue[i][row]
                    setValue = self.mf_setValue[i][row]
                    
                    if(tableWidget == self.uid.tableWidget_m3):
                        # a0, c0 are proportional to P0 rate of change when P0 is changed.
                        if(self.init == True and row == 1):
                            p0 = float(item.text())
                            a0_item = tableWidget.item(4, col)
                            a0 = float(a0_item.text())
                            c0_item = tableWidget.item(6, col)
                            c0 = float(c0_item.text())
                            def_p0 = defValue
                            dp0 = p0/def_p0
                            def_a0 = self.mf_defaultValue[i][4]
                            def_c0 = self.mf_defaultValue[i][6]
                            a0 = def_a0*dp0
                            c0 = def_c0*dp0
                            temp_item = QTableWidgetItem(str(a0))
                            tableWidget.setItem(4, 1, temp_item)
                            temp_item = QTableWidgetItem(str(c0))
                            tableWidget.setItem(6, 1, temp_item)

            # compare with default value
            try:
                if(round(float(item.text()), 10) != round(defValue, 10)):
                    item = QTableWidgetItem()
                    icon = QIcon()
                    icon.addPixmap(QPixmap("./resources/default.png"))
                    item.setIcon(icon)
                    item.setFlags(Qt.ItemIsEnabled)
                    tableWidget.setItem(row, 2, item)
                else:
                    item = QTableWidgetItem()
                    item.setFlags(Qt.ItemIsEnabled)  
                    tableWidget.setItem(row, 2, item) 
            except:
                item = QTableWidgetItem(str(setValue))
                tableWidget.setItem(row, 1, item)
    
    def returnDefaultValue(self, row, col):
        if(col == 2):  
            tableWidget = self.sender()
            
            for i in range(len(self.mn_tableWidget)):
                if(tableWidget == self.mn_tableWidget[i]):
                    # prevent return value of Eca that is deactivated.
                    if(tableWidget==self.uid.tableWidget_Sca):
                        if(row == 4):
                            if(not self.uid.checkBox_const_SEca.isChecked()):
                                continue
                    if(tableWidget==self.uid.tableWidget_Dca):
                        if(row == 4):
                            if(not self.uid.checkBox_const_DEca.isChecked()):
                                continue
                    
                    # return the default value
                    item = QTableWidgetItem(str(self.mn_defaultValue[i][row]))
                    self.mn_tableWidget[i].setItem(row, 1, item)
                    
            for i in range(len(self.mf_tableWidget)):
                if(tableWidget == self.mf_tableWidget[i]):
                    item = QTableWidgetItem(str(self.mf_defaultValue[i][row]))
                    self.mf_tableWidget[i].setItem(row, 1, item)
                
    def saveChEnable(self):
        # save the groupbox enable information
        if(self.uid.groupBox_Snaf.isChecked()):
            self.channel_enable['Snaf'] = True
            self.ch_enable_arr[2] = True
        else:
            self.channel_enable['Snaf'] = False
            self.ch_enable_arr[2] = False
        if(self.uid.groupBox_Snap.isChecked()):
            self.channel_enable['Snap'] = True
            self.ch_enable_arr[3] = True
        else:
            self.channel_enable['Snap'] = False
            self.ch_enable_arr[3] = False
        if(self.uid.groupBox_Skdr.isChecked()):
            self.channel_enable['Skdr'] = True
            self.ch_enable_arr[4] = True
        else:
            self.channel_enable['Skdr'] = False
            self.ch_enable_arr[4] = False
        if(self.uid.groupBox_Skca.isChecked()):
            self.channel_enable['Skca'] = True
            self.ch_enable_arr[5] = True
        else:
            self.channel_enable['Skca'] = False
            self.ch_enable_arr[5] = False
        if(self.uid.groupBox_Scan.isChecked()):
            self.channel_enable['Scan'] = True
            self.ch_enable_arr[6] = True
        else:
            self.channel_enable['Scan'] = False
            self.ch_enable_arr[6] = False
        if(self.uid.groupBox_Sh.isChecked()):
            self.channel_enable['Sh'] = True
            self.ch_enable_arr[7] = True
        else:
            self.channel_enable['Sh'] = False
            self.ch_enable_arr[7] = False
        if(self.uid.groupBox_Sesyn.isChecked()):
            self.channel_enable['Sesyn'] = True
        else:
            self.channel_enable['Sesyn'] = False
        if(self.uid.groupBox_Sisyn.isChecked()):
            self.channel_enable['Sisyn'] = True
        else:
            self.channel_enable['Sisyn'] = False
        if(self.uid.groupBox_Dcal.isChecked()):
            self.channel_enable['Dcal'] = True
            self.ch_enable_arr[11] = True
        else:
            self.channel_enable['Dcal'] = False
            self.ch_enable_arr[11] = False
        if(self.uid.groupBox_Dnaf.isChecked()):
            self.channel_enable['Dnaf'] = True
            self.ch_enable_arr[12] = True
        else:
            self.channel_enable['Dnaf'] = False
            self.ch_enable_arr[12] = False
        if(self.uid.groupBox_Dnap.isChecked()):
            self.channel_enable['Dnap'] = True
            self.ch_enable_arr[13] = True
        else:
            self.channel_enable['Dnap'] = False
            self.ch_enable_arr[13] = False
        if(self.uid.groupBox_Dkdr.isChecked()):
            self.channel_enable['Dkdr'] = True
            self.ch_enable_arr[14] = True
        else:
            self.channel_enable['Dkdr'] = False
            self.ch_enable_arr[14] = False
        if(self.uid.groupBox_Dkca.isChecked()):
            self.channel_enable['Dkca'] = True
            self.ch_enable_arr[15] = True
        else:
            self.channel_enable['Dkca'] = False
            self.ch_enable_arr[15] = False
        if(self.uid.groupBox_Dcan.isChecked()):
            self.channel_enable['Dcan'] = True
            self.ch_enable_arr[16] = True
        else:
            self.channel_enable['Dcan'] = False
            self.ch_enable_arr[16] = False
        if(self.uid.groupBox_Dh.isChecked()):
            self.channel_enable['Dh'] = True
            self.ch_enable_arr[17] = True
        else:
            self.channel_enable['Dh'] = False
            self.ch_enable_arr[17] = False
        if(self.uid.groupBox_Desyn.isChecked()):
            self.channel_enable['Desyn'] = True
        else:
            self.channel_enable['Desyn'] = False
        if(self.uid.groupBox_Disyn.isChecked()):
            self.channel_enable['Disyn'] = True
        else:
            self.channel_enable['Disyn'] = False
            
    def checkChEnable(self):
        # set the groupbox enable based on groupbox enable information
        if(self.channel_enable['Snaf'] == True):
            self.uid.groupBox_Snaf.setChecked(True)
        else:
            self.uid.groupBox_Snaf.setChecked(False)
        if(self.channel_enable['Snap'] == True):
            self.uid.groupBox_Snap.setChecked(True)
        else:
            self.uid.groupBox_Snap.setChecked(False)
        if(self.channel_enable['Skdr'] == True):
            self.uid.groupBox_Skdr.setChecked(True)
        else:
            self.uid.groupBox_Skdr.setChecked(False)
        if(self.channel_enable['Skca'] == True):
            self.uid.groupBox_Skca.setChecked(True)
        else:
            self.uid.groupBox_Skca.setChecked(False)
        if(self.channel_enable['Scan'] == True):
            self.uid.groupBox_Scan.setChecked(True)
        else:
            self.uid.groupBox_Scan.setChecked(False)
        if(self.channel_enable['Sh'] == True):
            self.uid.groupBox_Sh.setChecked(True)
        else:
            self.uid.groupBox_Sh.setChecked(False)
        if(self.channel_enable['Sesyn'] == True):
            self.uid.groupBox_Sesyn.setChecked(True)
        else:
            self.uid.groupBox_Sesyn.setChecked(False)
        if(self.channel_enable['Sisyn'] == True):
            self.uid.groupBox_Sisyn.setChecked(True)
        else:
            self.uid.groupBox_Sisyn.setChecked(False)
        if(self.channel_enable['Dcal'] == True):
            self.uid.groupBox_Dcal.setChecked(True)
        else:
            self.uid.groupBox_Dcal.setChecked(False)
        if(self.channel_enable['Dnaf'] == True):
            self.uid.groupBox_Dnaf.setChecked(True)
        else:
            self.uid.groupBox_Dnaf.setChecked(False)
        if(self.channel_enable['Dnap'] == True):
            self.uid.groupBox_Dnap.setChecked(True)
        else:
            self.uid.groupBox_Dnap.setChecked(False)
        if(self.channel_enable['Dkdr'] == True):
            self.uid.groupBox_Dkdr.setChecked(True)
        else:
            self.uid.groupBox_Dkdr.setChecked(False)
        if(self.channel_enable['Dkca'] == True):
            self.uid.groupBox_Dkca.setChecked(True)
        else:
            self.uid.groupBox_Dkca.setChecked(False)
        if(self.channel_enable['Dcan'] == True):
            self.uid.groupBox_Dcan.setChecked(True)
        else:
            self.uid.groupBox_Dcan.setChecked(False)
        if(self.channel_enable['Dh'] == True):
            self.uid.groupBox_Dh.setChecked(True)
        else:
            self.uid.groupBox_Dh.setChecked(False)
        if(self.channel_enable['Desyn'] == True):
            self.uid.groupBox_Desyn.setChecked(True)
        else:
            self.uid.groupBox_Desyn.setChecked(False)
        if(self.channel_enable['Disyn'] == True):
            self.uid.groupBox_Disyn.setChecked(True)
        else:
            self.uid.groupBox_Disyn.setChecked(False)

    def displayValue(self, value=[], index=2):
        # display set value
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):  
            self.checkChEnable()
            if(index != 0):
                param=self.mn_setValue
            else:
                param=value
            
            iter_num = self.mn_setValue_num
            idx = self.mn_idx
            k = 0            
            for i in range(iter_num):
                if(i == idx[k] and self.ch_enable_arr[k] == False):
                    item = QTableWidgetItem(str(self.pre_G[k]))
                else:
                    item = QTableWidgetItem(str(param[k][i-idx[k]]))
                self.mn_tableWidget[k].setItem(i-idx[k], 1, item)
                if(i == idx[k+1]-1):
                    k+=1    
        
        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'):
            if(index != 1):
                param=self.mf_setValue
            else:
                param=value            

            iter_num = self.mf_setValue_num
            idx = self.mf_idx
            k = 0            
            for i in range(iter_num):
                item = QTableWidgetItem(str(param[k][i-idx[k]]))
                self.mf_tableWidget[k].setItem(i-idx[k], 1, item)
                if(i == idx[k+1]-1):
                    k+=1
                    
        self.init = True
        
        if(self.MW.ModelType == 'Motoneuron'):
            self.uid.tabWidget.setTabEnabled(0, True)
            self.uid.tabWidget.setTabEnabled(1, False)
            self.checkValue()
            
        elif(self.MW.ModelType == 'Muscle Fibers'):
            self.uid.tabWidget.setTabEnabled(0, False)
            self.uid.tabWidget.setTabEnabled(1, True)
            
        elif(self.MW.ModelType == 'Motor Unit'):
            self.uid.tabWidget.setTabEnabled(0, True)
            self.uid.tabWidget.setTabEnabled(1, True)
            self.uid.tabWidget.setCurrentIndex(0) 
            self.checkValue()

    def openFile(self):
        curPath = os.path.dirname( os.path.abspath( sys.argv[0] ) )
        currentWidget = self.uid.tabWidget.currentWidget()        
        
        try:
            if(currentWidget == self.uid.mn_tab):
                model = 'Motoneuron'                
            elif(currentWidget == self.uid.mf_tab):
                model = 'Muscle Fibers'
            fileName = QFileDialog.getOpenFileName(self,"Open a " + model + " Parameter File (Must be a csv format)", curPath+"/parameters", "CSV Files (*.csv)")
        except:
            self.MW.setTextEdit("[Error] Failed to open file.")
            self.MW.raise_()
            self.MW.activateWindow()
        
        if(fileName != ''):
            self.importData(fileName, currentWidget)
    
    def importData(self, fileName, currentWidget):
        try:
            param = pd.read_csv(unicode(fileName))
            tempValue = range(len(param.index))
            for i in range(len(param.index)):
                tempValue[i] = float(param.Value[i])
            
            if(currentWidget == self.uid.mn_tab):
                if(len(tempValue) != self.mn_setValue_num):
                    raise Exception
                iter_num = len(self.mn_idx)
                idx = self.mn_idx
                lstSlice_arr = range(len(self.mn_idx)-1)
            elif(currentWidget == self.uid.mf_tab):
                if(len(tempValue) != self.mf_setValue_num):
                    raise Exception
                iter_num = len(self.mf_idx)
                idx = self.mf_idx
                lstSlice_arr = range(len(self.mf_idx)-1)
            for i in range(1, iter_num):
                lstSlice_arr[i-1] = tempValue[idx[i-1]:idx[i]] 
                if(math.isnan(tempValue[i])):
                    raise Exception  
            dispValue = lstSlice_arr
        
        except:
            self.MW.setTextEdit("[Error] Failed to load data.")
            self.MW.raise_()
            self.MW.activateWindow()
            return
        
        if(currentWidget == self.uid.mn_tab):
            i = 0
            self.uid.mn_lineEdit.setText(fileName)
        elif(currentWidget == self.uid.mf_tab):
            i = 1
            self.uid.mf_lineEdit.setText(fileName)
        
        self.displayValue(dispValue, i)
        self.uid.tabWidget.setCurrentIndex(i)

    def setValue(self):
        # set the value
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):
            self.saveChEnable()
            
            iter_num = self.mn_setValue_num
            idx = self.mn_idx 
            k = 0            
            for i in range(iter_num):
                item = self.mn_tableWidget[k].item(i-idx[k], 1)
                if(i == idx[k] and self.ch_enable_arr[k] == False):
                    # save the previous G value and set the G to zero. 
                    self.pre_G[k] = float(item.text())
                    self.mn_setValue[k][i-idx[k]] = 0.
                else:
                    self.mn_setValue[k][i-idx[k]] = float(item.text()) 
                if(i == idx[k+1]-1):
                    k+=1
                    
            # set the synapic conductance signal based on channel enable information.
            if(self.channel_enable['Sesyn'] == True):
                self.MW.SGW.se_ch = True
            else:
                self.MW.SGW.se_ch = False
            if(self.channel_enable['Sisyn'] == True):
                self.MW.SGW.si_ch = True
            else:
                self.MW.SGW.si_ch = False
            if(self.channel_enable['Desyn'] == True):
                self.MW.SGW.de_ch = True
            else:
                self.MW.SGW.de_ch = False
            if(self.channel_enable['Disyn'] == True):
                self.MW.SGW.di_ch = True
            else:
                self.MW.SGW.di_ch = False
            self.MW.MN.setSynConSignal(self.MW.SGW.se_ch, self.MW.SGW.si_ch, self.MW.SGW.de_ch, self.MW.SGW.di_ch, self.MW.SGW.s_SCSG.e_times, self.MW.SGW.s_SCSG.i_times, self.MW.SGW.d_SCSG.e_times, self.MW.SGW.d_SCSG.i_times, self.MW.SGW.s_SCSG.G_e, self.MW.SGW.s_SCSG.G_i, self.MW.SGW.d_SCSG.G_e, self.MW.SGW.d_SCSG.G_i)

        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'):
            iter_num = self.mf_setValue_num
            idx = self.mf_idx
            k = 0            
            for i in range(iter_num):
                item = self.mf_tableWidget[k].item(i-idx[k], 1)
                self.mf_setValue[k][i-idx[k]] = float(item.text())
                if(i == idx[k+1]-1):
                    k+=1

        # Text message
        if(self.MW.ModelType == 'Motoneuron'):
            self.MW.MN.setModelParam(self.mn_setValue, self.const_sEca, self.const_dEca)
            self.MW.setTextEdit("[Motoneuron] Parameter values set.")
        elif(self.MW.ModelType == 'Muscle Fibers'):
            self.MW.MF.setModelParam(self.mf_setValue)
            self.MW.setTextEdit("[Muscle Fibers] Parameter values set.")
        elif(self.MW.ModelType == 'Motor Unit'):
            self.MW.MU.setModelParam(self.mn_setValue, self.mf_setValue, self.const_sEca, self.const_dEca)
            self.MW.setTextEdit("[Motor Unit] Parameter values set.")
            
        # update pop-up window enable 
        self.MW.ISW.setObjectEnabled()
        self.MW.SGW.setObjectEnabled()
        self.MW.OW.setObjectEnabled(False)
            
# Simulation Condition Setting Window class           
class IntegrationSettingWindow(QDialog):
    def __init__(self, MW):
        super(IntegrationSettingWindow, self).__init__()
        self.MW = MW
        
        # subscript, superscript, Greek letter with unicode and unit label
        super_2 = u'\u00B2' 
        super_2_p = super_2+u'\u207A'
        sub_i = u'\u1D62'
        mV = ' (mV)'
        mM = ' (mM)'
        tilde = u'\u0303'
        mm = ' (mm)'
        M = ' (M)'
        
        # subscript with HTML
        sub_Naf = '<sub>Naf</sub>'
        sub_Nap = '<sub>Nap</sub>'
        sub_Kdr = '<sub>Kdr</sub>'
        sub_Can = '<sub>Can</sub>'
        sub_H = '<sub>H</sub>'
        sub_Cal = '<sub>Cal</sub>'
        sub_SR = '<sub>SR</sub>'
        sub_SP = '<sub>SP</sub>'
        sub_CE = '<sub>CE</sub>'
        
        ## initialization
        # set value
        self.t_setTable = [0., 10000., 0.1, 100.]
        self.t_start, self.t_stop, self.t_dt, self.t_pt = self.t_setTable
        self.mn_setValue = [[-70.], 
                            [0.0001], 
                            [0.001, 0.5829], 
                            [0.001],
                            [0.1239],
                            [0.004199, 0.9219],
                            [0.], 
                            [-70.],
                            [0.0001],
                            [0.001],
                            [0.001, 0.5829], 
                            [0.001], 
                            [0.1239], 
                            [0.004199, 0.9219], 
                            [0.]]
        self.mn_idx = [0, 1, 2, 4, 5, 6, 8, 9, 10, 11, 12, 14, 15, 16, 18, 19]
        self.mn_setValue_num = 19
        
        self.mf_setValue = [[0.03, 0.0025, 0., 0.00043, 1.e-7, 0.00007, 0., 0.],
                            [0.],
                            [-8.]] 
        self.mf_idx = [0, 8, 9, 10]     
        self.mf_setValue_num = 10
        
        # default value
        self.t_defaultTable = tuple(self.t_setTable)
        self.def_time_num = 4 
        self.mn_defaultValue = copy.deepcopy(self.mn_setValue) 
        self.mf_defaultValue = copy.deepcopy(self.mf_setValue)
        
        ## GUI
        self.uid = Ui_ID()
        self.uid.setupUi(self)
        self.mn_tableWidget = [self.uid.tableWidget_Sv,
                               self.uid.tableWidget_Sca,
                               self.uid.tableWidget_Snaf,
                               self.uid.tableWidget_Snap,
                               self.uid.tableWidget_Skdr,
                               self.uid.tableWidget_Scan,
                               self.uid.tableWidget_Sh,
                               self.uid.tableWidget_Dv,
                               self.uid.tableWidget_Dca,
                               self.uid.tableWidget_Dcal,
                               self.uid.tableWidget_Dnaf,
                               self.uid.tableWidget_Dnap,
                               self.uid.tableWidget_Dkdr,
                               self.uid.tableWidget_Dcan,
                               self.uid.tableWidget_Dh]
        self.mf_tableWidget = [self.uid.tableWidget_m1, 
                               self.uid.tableWidget_m2, 
                               self.uid.tableWidget_m3]
        
        # groupbox label
        self.uid.groupBox_Sca.setTitle('d[Ca' + super_2_p + ']' + sub_i + '/dt  ')
        self.uid.label_Snaf.setText('I' + sub_Naf)
        self.uid.label_Snap.setText('I' + sub_Nap)
        self.uid.label_Skdr.setText('I' + sub_Kdr)
        self.uid.label_Scan.setText('I' + sub_Can)
        self.uid.label_Sh.setText('I' + sub_H)
        self.uid.groupBox_Dca.setTitle('d[Ca' + super_2_p + ']' + sub_i + '/dt  ')
        self.uid.label_Dcal.setText('I' + sub_Cal)
        self.uid.label_Dnaf.setText('I' + sub_Naf)
        self.uid.label_Dnap.setText('I' + sub_Nap)
        self.uid.label_Dkdr.setText('I' + sub_Kdr)
        self.uid.label_Dcan.setText('I' + sub_Can)
        self.uid.label_Dh.setText('I' + sub_H)
        
        # lineEdit
        self.lineEdit = []
        self.lineEdit.append(self.uid.lineEdit_2)
        self.lineEdit.append(self.uid.lineEdit_3)
        self.lineEdit.append(self.uid.lineEdit_4)
        
        # checkBox
        self.checkBox = []
        self.checkBox.append(self.uid.checkBox_2)
        self.checkBox.append(self.uid.checkBox_3)
        self.checkBox.append(self.uid.checkBox_4)
        self.checkBox[0].setEnabled(False)
        self.checkBox[1].setEnabled(False)
        self.checkBox[2].setEnabled(False)
        
        # ivalue label
        mn_ivalue_1 = QLabel('V' + mV)
        mn_ivalue_2 = QLabel('[Ca' + super_2_p + ']' + sub_i + mM)
        mn_ivalue_3 = QLabel('m')
        mn_ivalue_4 = QLabel('h')
        mn_ivalue_5 = QLabel('m') 
        mn_ivalue_6 = QLabel('n') 
        mn_ivalue_7 = QLabel('m')
        mn_ivalue_8 = QLabel('h')
        mn_ivalue_9 = QLabel('m')
        mn_ivalue_12 = QLabel('V' + mV)
        mn_ivalue_13 = QLabel('[Ca' + super_2_p + ']' + sub_i + mM)
        mn_ivalue_14 = QLabel(' l')
        mn_ivalue_15 = QLabel('m')
        mn_ivalue_16 = QLabel('h')
        mn_ivalue_17 = QLabel('m')
        mn_ivalue_18 = QLabel('n')
        mn_ivalue_19 = QLabel('m')
        mn_ivalue_20 = QLabel('h')
        mn_ivalue_21 = QLabel('m')
        mf_ivalue_1 = QLabel('[CS]' + M)
        mf_ivalue_2 = QLabel('[Ca' + sub_SR + ']' + M)
        mf_ivalue_3 = QLabel('[Ca' + sub_SR + 'CS]' + M)
        mf_ivalue_4 = QLabel('[B]' + M)
        mf_ivalue_5 = QLabel('[Ca' + sub_SP + ']' + M)
        mf_ivalue_6 = QLabel('[T]' + M)
        mf_ivalue_7 = QLabel('[Ca' + sub_SP + 'B]' + M)
        mf_ivalue_8 = QLabel('[Ca' + sub_SP + 'T]' + M)
        mf_ivalue_9 = QLabel('A' + tilde)
        mf_ivalue_10 = QLabel('X' + sub_CE + mm)
        
        mn_ivalue = []
        mn_ivalue.append(mn_ivalue_1)
        mn_ivalue.append(mn_ivalue_2)
        mn_ivalue.append(mn_ivalue_3)
        mn_ivalue.append(mn_ivalue_4)
        mn_ivalue.append(mn_ivalue_5)
        mn_ivalue.append(mn_ivalue_6)
        mn_ivalue.append(mn_ivalue_7)
        mn_ivalue.append(mn_ivalue_8)
        mn_ivalue.append(mn_ivalue_9)
        mn_ivalue.append(mn_ivalue_12)
        mn_ivalue.append(mn_ivalue_13)
        mn_ivalue.append(mn_ivalue_14)
        mn_ivalue.append(mn_ivalue_15)
        mn_ivalue.append(mn_ivalue_16)
        mn_ivalue.append(mn_ivalue_17)
        mn_ivalue.append(mn_ivalue_18)
        mn_ivalue.append(mn_ivalue_19)
        mn_ivalue.append(mn_ivalue_20)      
        mn_ivalue.append(mn_ivalue_21)
        mf_ivalue = []
        mf_ivalue.append(mf_ivalue_1)
        mf_ivalue.append(mf_ivalue_2)
        mf_ivalue.append(mf_ivalue_3)
        mf_ivalue.append(mf_ivalue_4)
        mf_ivalue.append(mf_ivalue_5)
        mf_ivalue.append(mf_ivalue_6)
        mf_ivalue.append(mf_ivalue_7)
        mf_ivalue.append(mf_ivalue_8)
        mf_ivalue.append(mf_ivalue_9)
        mf_ivalue.append(mf_ivalue_10)

        # tableWidget
        # row, column
        col_num = 3
        iter_num = len(self.mn_setValue)
        for i in range(iter_num):
            self.mn_tableWidget[i].setColumnCount(col_num)
            self.mn_tableWidget[i].setRowCount(len(self.mn_setValue[i]))
        
        iter_num = len(self.mf_setValue)
        for i in range(iter_num):
            self.mf_tableWidget[i].setColumnCount(col_num)
            self.mf_tableWidget[i].setRowCount(len(self.mf_setValue[i]))
        
        # label
        iter_num = len(mn_ivalue)
        idx = self.mn_idx 
        k = 0
        for i in range(iter_num):
            self.mn_tableWidget[k].setCellWidget(i-idx[k], 0, mn_ivalue[i])
            if(i == idx[k+1]-1):
                k+=1
        
        iter_num = len(mf_ivalue)
        idx = self.mf_idx
        k = 0
        for i in range(iter_num):
            self.mf_tableWidget[k].setCellWidget(i-idx[k], 0, mf_ivalue[i])
            if(i == idx[k+1]-1):
                k+=1

        # deactivation cell
        iter_num = len(mn_ivalue)
        idx = self.mn_idx 
        k = 0
        for i in range(iter_num):
            item = QTableWidgetItem()
            item.setFlags(Qt.ItemIsEnabled)
            self.mn_tableWidget[k].setItem(i-idx[k], 2, item)
            if(i == idx[k+1]-1):
                k+=1
        
        iter_num = len(mf_ivalue)
        idx = self.mf_idx
        k = 0
        for i in range(iter_num):
            item = QTableWidgetItem()
            item.setFlags(Qt.ItemIsEnabled)
            self.mf_tableWidget[k].setItem(i-idx[k], 2, item)
            if(i == idx[k+1]-1):
                k+=1
            
        # GUI operation-function 
        self.uid.buttonBox.connect(self.uid.buttonBox, SIGNAL("accepted()"), self.setValue)
        self.uid.buttonBox.connect(self.uid.applyButton, SIGNAL("clicked()"), self.setValue)
        self.uid.lineEdit_2.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_3.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_4.editingFinished.connect(self.checkValue)
        self.uid.checkBox_2.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_3.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_4.stateChanged.connect(self.returnDefaultValue)
        self.uid.tableWidget_Sv.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Sca.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Snaf.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Snap.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Skdr.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Scan.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Sh.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dv.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dca.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dcal.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dnaf.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dnap.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dkdr.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dcan.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Dh.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_m1.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_m2.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_m3.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_Sv.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Sca.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Snaf.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Snap.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Skdr.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Scan.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Sh.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dv.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dca.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dcal.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dnaf.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dnap.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dkdr.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dcan.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_Dh.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_m1.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_m2.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_m3.cellChanged.connect(self.checkValue)
        
    def keyPressEvent(self, event):
        # operation of Key_Return or Key_Enter
        if(event.key() == 0x01000005 or event.key() == 0x01000004): 
            for i in range(len(self.lineEdit)):            
                self.lineEdit[i].clearFocus()
        else:
            # QDialog event
            super(IntegrationSettingWindow, self).keyPressEvent(event)

    def checkValue(self, row=1, col=3):
        # time tab value change
        if(col == 3):                    
            for i in range(self.def_time_num-1):
                try:                       
                    # set default value if the value is '0' or negative number                        
                    if(np.sign(float(self.lineEdit[i].text())) != 1):
                        self.lineEdit[i].setText(str(self.t_defaultTable[i+1]))
                        
                    # compare with default value
                    if(round(float(self.lineEdit[i].text()), 10) != round(self.t_defaultTable[i+1], 10)):   
                        self.checkBox[i].setCheckState(Qt.Checked)
                        self.checkBox[i].setEnabled(True)
                    else:
                        self.checkBox[i].setCheckState(Qt.Unchecked)
                        self.checkBox[i].setEnabled(False)
                except:
                    self.lineEdit[i].setText(str(self.t_setTable[i+1]))
        
        # tableWidget value change
        elif(col == 1):
            tableWidget = self.sender()
            for i in range(len(self.mn_tableWidget)):
                if(tableWidget == self.mn_tableWidget[i]):
                    item = tableWidget.item(row, col)
                    defValue = self.mn_defaultValue[i][row]
                    setValue = self.mn_setValue[i][row]

            for i in range(len(self.mf_tableWidget)):
                if(tableWidget == self.mf_tableWidget[i]):
                    item = tableWidget.item(row, col)
                    defValue = self.mf_defaultValue[i][row]
                    setValue = self.mf_setValue[i][row]
            
            try:
                # compare with default value
                if(round(float(item.text()), 10) != round(defValue, 10)):
                    item = QTableWidgetItem()
                    icon = QIcon()
                    icon.addPixmap(QPixmap("./resources/default.png"))
                    item.setIcon(icon)
                    item.setFlags(Qt.ItemIsEnabled)
                    tableWidget.setItem(row, 2, item)
                else:
                    item = QTableWidgetItem()
                    item.setFlags(Qt.ItemIsEnabled)  
                    tableWidget.setItem(row, 2, item) 
            except:
                item = QTableWidgetItem(str(setValue))
                tableWidget.setItem(row, 1, item)
                
    def returnDefaultValue(self, row, col=3):
        # time tab
        if(col == 3):
            checkBox = self.sender()
            
            # find checkBox index
            if(not checkBox.isChecked()):
                for i in range(self.def_time_num-1):
                        if(self.checkBox[i] == checkBox):
                            break
                
                # return the default value
                self.lineEdit[i].setText(str(self.t_defaultTable[i+1]))
                self.checkBox[i].setEnabled(False)
                
                # prevent widget focus
                if((i+1) < self.def_time_num-1): 
                    self.lineEdit[i+1].clearFocus()
        
        # tableWidget
        elif(col == 2): 
            tableWidget = self.sender()
            
            # return the default value
            for i in range(len(self.mn_tableWidget)):
                if(tableWidget == self.mn_tableWidget[i]):
                    item = QTableWidgetItem(str(self.mn_defaultValue[i][row]))
                    self.mn_tableWidget[i].setItem(row, 1, item)
            
            for i in range(len(self.mf_tableWidget)):
                if(tableWidget == self.mf_tableWidget[i]):
                    item = QTableWidgetItem(str(self.mf_defaultValue[i][row]))
                    self.mf_tableWidget[i].setItem(row, 1, item)
            
    def setObjectEnabled(self):
        # object enable setting
        if(self.MW.PSW.channel_enable['Snaf'] == True):
            self.uid.groupBox_Snaf.setEnabled(True)
        else:
            self.uid.groupBox_Snaf.setEnabled(False)
        if(self.MW.PSW.channel_enable['Snap'] == True):
            self.uid.groupBox_Snap.setEnabled(True)
        else:
            self.uid.groupBox_Snap.setEnabled(False)
        if(self.MW.PSW.channel_enable['Skdr'] == True):
            self.uid.groupBox_Skdr.setEnabled(True)
        else:
            self.uid.groupBox_Skdr.setEnabled(False)
        if(self.MW.PSW.channel_enable['Scan'] == True):
            self.uid.groupBox_Scan.setEnabled(True)
        else:
            self.uid.groupBox_Scan.setEnabled(False)
        if(self.MW.PSW.channel_enable['Sh'] == True):
            self.uid.groupBox_Sh.setEnabled(True)
        else:
            self.uid.groupBox_Sh.setEnabled(False)
        if(self.MW.PSW.channel_enable['Dcal'] == True):
            self.uid.groupBox_Dcal.setEnabled(True)
        else:
            self.uid.groupBox_Dcal.setEnabled(False)
        if(self.MW.PSW.channel_enable['Dnaf'] == True):
            self.uid.groupBox_Dnaf.setEnabled(True)
        else:
            self.uid.groupBox_Dnaf.setEnabled(False)
        if(self.MW.PSW.channel_enable['Dnap'] == True):
            self.uid.groupBox_Dnap.setEnabled(True)
        else:
            self.uid.groupBox_Dnap.setEnabled(False)
        if(self.MW.PSW.channel_enable['Dkdr'] == True):
            self.uid.groupBox_Dkdr.setEnabled(True)
        else:
            self.uid.groupBox_Dkdr.setEnabled(False)
        if(self.MW.PSW.channel_enable['Dcan'] == True):
            self.uid.groupBox_Dcan.setEnabled(True)
        else:
            self.uid.groupBox_Dcan.setEnabled(False)
        if(self.MW.PSW.channel_enable['Dh'] == True):
            self.uid.groupBox_Dh.setEnabled(True)
        else:
            self.uid.groupBox_Dh.setEnabled(False)
        
    def displayValue(self):
        ## display set value
        # time
        self.uid.lineEdit_2.setText(str(self.t_setTable[1]))
        self.uid.lineEdit_3.setText(str(self.t_setTable[2]))
        self.uid.lineEdit_4.setText(str(self.t_setTable[3]))
        
        # tableWidget
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):
            self.setObjectEnabled()
            iter_num = self.mn_setValue_num
            idx = self.mn_idx
            k = 0            
            for i in range(iter_num):
                item = QTableWidgetItem(str(self.mn_setValue[k][i-idx[k]]))
                self.mn_tableWidget[k].setItem(i-idx[k], 1, item)
                if(i == idx[k+1]-1):
                    k+=1
        
        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'):
            iter_num = self.mf_setValue_num
            idx = self.mf_idx 
            k = 0            
            for i in range(iter_num):
                item = QTableWidgetItem(str(self.mf_setValue[k][i-idx[k]]))
                self.mf_tableWidget[k].setItem(i-idx[k], 1, item)
                if(i == idx[k+1]-1):
                    k+=1
                    
        # tab enable
        if(self.MW.ModelType == 'Motoneuron'):
            self.uid.tabWidget.setTabEnabled(1, True)
            self.uid.tabWidget.setTabEnabled(2, False)
            self.uid.tabWidget.setCurrentIndex(0)
            
        elif(self.MW.ModelType == 'Muscle Fibers'):
            self.uid.tabWidget.setTabEnabled(1, False)
            self.uid.tabWidget.setTabEnabled(2, True)
            self.uid.tabWidget.setCurrentIndex(0) 
            
        elif(self.MW.ModelType == 'Motor Unit'):
            self.uid.tabWidget.setTabEnabled(1, True)
            self.uid.tabWidget.setTabEnabled(2, True)
            self.uid.tabWidget.setCurrentIndex(0)
            
        self.checkValue()

    def setValue(self):
        ## set the value
        # time
        self.t_stop = float(self.uid.lineEdit_2.text())
        
        # warning of changing dt 
        if(round(self.t_dt, 10) != round(float(self.uid.lineEdit_3.text()), 10)):   
            self.MW.setTextEdit("[Warning] Please regenerate input signals for new sample time.")
        self.t_dt = float(self.uid.lineEdit_3.text())
        self.t_pt = float(self.uid.lineEdit_4.text())
        self.t_setTable = self.t_start, self.t_stop, self.t_dt, self.t_pt

        if(self.MW.ModelType == 'Motoneuron'):
            self.MW.MN.setIntegrationEnv(self.t_start, self.t_stop, self.t_dt, self.t_pt)
        elif(self.MW.ModelType == 'Muscle Fibers'):
            self.MW.MF.setIntegrationEnv(self.t_start, self.t_stop, self.t_dt, self.t_pt)
        elif(self.MW.ModelType == 'Motor Unit'):
            self.MW.MU.setIntegrationEnv(self.t_start, self.t_stop, self.t_dt, self.t_pt)
            
        # tableWidget
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):
            iter_num = self.mn_setValue_num
            idx = self.mn_idx
            k = 0            
            for i in range(iter_num):
                item = self.mn_tableWidget[k].item(i-idx[k], 1)
                self.mn_setValue[k][i-idx[k]] = float(item.text())
                if(i == idx[k+1]-1):
                    k+=1
        
        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'):
            iter_num = self.mf_setValue_num 
            idx = self.mf_idx
            k = 0            
            for i in range(iter_num):
                item = self.mf_tableWidget[k].item(i-idx[k], 1)
                self.mf_setValue[k][i-idx[k]] = float(item.text())
                if(i == idx[k+1]-1):
                    k+=1
        
        # Text message        
        if(self.MW.ModelType == 'Motoneuron'):
            self.MW.MN.setInitialValues(self.mn_setValue)
            self.MW.setTextEdit("[Motoneuron] Simulation conditions set.")
        elif(self.MW.ModelType == 'Muscle Fibers'):
            self.MW.MF.setInitialValues(self.mf_setValue)
            self.MW.setTextEdit("[Muscle Fibers] Simulation conditions set.")
        elif(self.MW.ModelType == 'Motor Unit'):
            self.MW.MU.setInitialValues(self.mn_setValue, self.mf_setValue)
            self.MW.setTextEdit("[Motor Unit] Simulation conditions set.")
        
# Input Signals Window class
class SignalGeneratorWindow(QDialog):
    def __init__(self, MW):
        super(SignalGeneratorWindow, self).__init__()
        self.MW = MW
        #figure
        self.is_fig = None
        self.syn_fig = None
        self.sp_fig = None
        self.xm_fig = None
        # synapse channel enable
        self.se_ch=True
        self.si_ch=True
        self.de_ch=True
        self.di_ch=True
        self.syn_ch = [self.se_ch, self.si_ch, self.de_ch, self.di_ch]
        self.exp_syn_time = [0,0,0,0]
        self.exp_syn = [0,0,0,0]
        # simulation time
        self.t_start, self.t_final, self.t_dt, self.t_pt = self.MW.ISW.t_setTable
        period = self.t_final/2
        # generated signal type
        self.gen_isType = 'Step'
        self.gen_synType = ['Step','Step','Step','Step']
        self.gen_spikeType = 'User'
        self.gen_xmType = 'isometric'
        
        ## initialization
        # set value
        self.setTable = [0., 20., 5000., 100., 1500., 10., 0., -8., 0., -16., 600., 800.]
        self.isF_setValue = [6.795, 0.5, 1000., 1300., -0.3, 3000., 3300., 0.37, 5000., 9000., 0.45, 6500., 6800., -0.37, 9000., 9300., 17.]
        sesynF_setValue = [0.029, 0.02, 1000., 1300., -0.028, 3000., 3300., 0.013, 5000., 9000., 0.03, 6500., 6800., -0.1, 9000., 9300., 1., 0.5, 0.03]
        sisynF_setValue = [0.029, 0.02, 1000., 1300., -0.028, 3000., 3300., 0.013, 5000., 9000., 0.03, 6500., 6800., -0.1, 9000., 9300., 1., 2., 0.06]
        desynF_setValue = [0.029, 0.02, 1000., 1300., -0.028, 3000., 3300., 0.013, 5000., 9000., 0.03, 6500., 6800., -0.1, 9000., 9300., 1., 0.5, 0.03]
        disynF_setValue = [0.029, 0.02, 1000., 1300., -0.028, 3000., 3300., 0.013, 5000., 9000., 0.03, 6500., 6800., -0.1, 9000., 9300., 1., 2., 0.06]
        self.synF_setValue = [sesynF_setValue,sisynF_setValue,desynF_setValue,disynF_setValue]
        self.synF_idx = [0,19,38,57,76,77]
        self.synF_num = 76
        sesynT_setValue = [0., 0.1, period, 0.5, 0.03]
        sisynT_setValue = [0.1, 0,  period, 2.,  0.06]
        desynT_setValue = [0., 0.1, period, 0.5, 0.03]
        disynT_setValue = [0., 0.1,  period, 2.,  0.06]
        self.synT_setValue = [sesynT_setValue, sisynT_setValue, desynT_setValue, disynT_setValue]
        self.synT_idx = [0,5,10,15,20,21]
        self.synT_num = 20
        syn_idx = [0,19,24,43,48,67,72,91,96,97]
        syn_num = 96
        
        # default value
        self.default_num = 12
        self.defaultTable = tuple(self.setTable)
        self.isF_defValue = tuple(self.isF_setValue)
        self.synF_defValue = copy.deepcopy(self.synF_setValue)
        self.synT_defValue = copy.deepcopy(self.synT_setValue) 
        
        # generated signals
        self.gen_isF_heav = self.isF_setValue[:]
        self.gen_is_iValue = 0.
        self.gen_is_pValue = 20.
        self.gen_is_period = period
        gen_sesynF_heav = sesynF_setValue[:17]
        gen_sisynF_heav = sisynF_setValue[:17]
        gen_desynF_heav = desynF_setValue[:17]
        gen_disynF_heav = disynF_setValue[:17]
        self.gen_spike_t1 = 100.
        self.gen_spike_t2 = 1500.
        self.gen_spike_hz = 10.
        self.gen_spike_scale = 0.
        self.gen_xm_value = -8.
        self.gen_xm_value1 = 0.
        self.gen_xm_value2 = -16.
        self.gen_xm_t1 = 600.
        self.gen_xm_t2 = 800.
        self.gen_synF_heav=[gen_sesynF_heav, gen_sisynF_heav, gen_desynF_heav, gen_disynF_heav]
        self.gen_synF_tau=[0.5, 2., 0.5, 2.]
        self.gen_synF_std_max=[0.03, 0.06, 0.03, 0.06]
        self.gen_synT_iValue=[0., 0., 0., 0.]
        self.gen_synT_pValue=[0.12, 0.12, 0.12, 0.12] 
        self.gen_synT_period=[period, period, period, period]
        self.gen_synT_tau=[0.5, 2., 0.5, 2.]
        self.gen_synT_std_max =[0.03, 0.06, 0.03, 0.06]        

        # Generator class
        self.ISG = InputSignalGenerator('Step', self.t_final, self.t_dt, self.gen_isF_heav)
        self.ISG.genSignal()
        self.s_SCSG = SynConSignalGenerator('Excitatory', 'Step', self.t_final, self.t_dt, gen_sesynF_heav)
        self.s_SCSG.genSignal()
        self.s_SCSG.setValue('Inhibitory', 'Step', self.t_final, self.t_dt, gen_sisynF_heav)
        self.s_SCSG.genSignal()
        self.d_SCSG = SynConSignalGenerator('Excitatory', 'Step', self.t_final, self.t_dt, gen_desynF_heav)
        self.d_SCSG.genSignal()
        self.d_SCSG.setValue('Inhibitory', 'Step', self.t_final, self.t_dt, gen_disynF_heav)
        self.d_SCSG.genSignal()
        self.SSG = SpikeSignalGenerator('User', self.t_final, self.t_dt, self.setTable[3], self.setTable[4], self.setTable[5], self.setTable[6])
        self.SSG.genSignal()
        self.XSG = XmSignalGenerator('Isometric', self.t_final, self.t_dt, self.setTable[7])
        self.XSG.genSignal()
        
        # subscript, superscript, Greek letter with unicode and unit label
        super_2 = u'\u00B2'
        mS_cm_2 = ' (mS/cm'+super_2+')'
        nA = ' (nA)'
        ms = ' (ms)'
        sub_0 = u'\u2080'
        sub_1 = u'\u2081'
        sub_2 = u'\u2082'
        sub_3 = u'\u2083'
        sub_4 = u'\u2084'
        sub_5 = u'\u2085'
        tau = u'\u03C4'
        
        # subscript with HTML
        sub_max = '<sub>max</sub>'
        sub_p = '<sub>p</sub>'
        sub_on = '<sub>on</sub>'
        sub_off = '<sub>off</sub>'
        
        ## GUI
        self.uid = Ui_SGD()
        self.uid.setupUi(self)
        self.uid.sp_lineEdit.setReadOnly(True)
        self.uid.xm_lineEdit.setReadOnly(True)
        
        #groupBox
        self.groupBox_syn = [self.uid.groupBox_sesyn,self.uid.groupBox_sisyn,self.uid.groupBox_desyn,self.uid.groupBox_disyn]
        
        # tableWidget
        self.syn_tableWidget_F = [self.uid.tableWidget_sesynF,self.uid.tableWidget_sisynF,self.uid.tableWidget_desynF,self.uid.tableWidget_disynF]
        self.syn_tableWidget_T = [self.uid.tableWidget_sesynT,self.uid.tableWidget_sisynT,self.uid.tableWidget_desynT,self.uid.tableWidget_disynT]
        
        # lineEdit
        self.syn_lineEdit = [self.uid.sesyn_lineEdit,self.uid.sisyn_lineEdit,self.uid.desyn_lineEdit,self.uid.disyn_lineEdit]
        
        # pushButton
        self.syn_load_pushButton = [self.uid.sesyn_load_pushButton,self.uid.sisyn_load_pushButton,self.uid.desyn_load_pushButton,self.uid.disyn_load_pushButton]
        
        # Isoma radio button
        self.isFixBtn = self.uid.radioButton
        self.isTriBtn = self.uid.radioButton_2
        self.isImtBtn = self.uid.radioButton_17
        
        # Isyn noise checkbox
        self.sesyn_noise = self.uid.sesyn_noise
        self.sisyn_noise = self.uid.sisyn_noise
        self.desyn_noise = self.uid.desyn_noise
        self.disyn_noise = self.uid.disyn_noise
        self.syn_noise = [self.sesyn_noise,self.sisyn_noise,self.desyn_noise,self.disyn_noise]
        
        # Isyn radio button
        syn_SeFixBtn = self.uid.radioButton_9 
        syn_SeTriBtn = self.uid.radioButton_10 
        syn_SeImtBtn = self.uid.radioButton_18
        syn_SiFixBtn = self.uid.radioButton_11
        syn_SiTriBtn = self.uid.radioButton_12
        syn_SiImtBtn = self.uid.radioButton_19
        syn_DeFixBtn = self.uid.radioButton_13 
        syn_DeTriBtn = self.uid.radioButton_14 
        syn_DeImtBtn = self.uid.radioButton_20 
        syn_DiFixBtn = self.uid.radioButton_15 
        syn_DiTriBtn = self.uid.radioButton_16 
        syn_DiImtBtn = self.uid.radioButton_21
        self.syn_FixBtn = [syn_SeFixBtn,syn_SiFixBtn,syn_DeFixBtn,syn_DiFixBtn]
        self.syn_TriBtn = [syn_SeTriBtn,syn_SiTriBtn,syn_DeTriBtn,syn_DiTriBtn]
        self.syn_ImtBtn = [syn_SeImtBtn,syn_SiImtBtn,syn_DeImtBtn,syn_DiImtBtn]
        
        # Iaxon radio button
        self.spUserBtn = self.uid.radioButton_3
        self.spExpBtn = self.uid.radioButton_4
        
        # Xm radio button
        self.xmIsomeBtn = self.uid.radioButton_5 
        self.xmIsokiBtn = self.uid.radioButton_6 
        self.xmDyBtn = self.uid.radioButton_7 
        self.xmExpBtn = self.uid.radioButton_8 
        
        # parameter label 
        isF_parameter_1 = QLabel('I' + sub_0 + nA)
        isF_parameter_2 = QLabel('I' + sub_p + sub_1 +nA)
        isF_parameter_3 = QLabel('T' + sub_on + ' ' + sub_p + sub_1 + ms)
        isF_parameter_4 = QLabel('T' + sub_off + ' '+ sub_p + sub_1 + ms)
        isF_parameter_5 = QLabel('I' + sub_p + sub_2 + nA)
        isF_parameter_6 = QLabel('T' + sub_on + ' ' + sub_p + sub_2 + ms)
        isF_parameter_7 = QLabel('T' + sub_off + ' '+ sub_p + sub_2 + ms)
        isF_parameter_8 = QLabel('I' + sub_p + sub_3 + nA)
        isF_parameter_9 = QLabel('T' + sub_on + ' ' + sub_p + sub_3 + ms)
        isF_parameter_10 = QLabel('T' + sub_off + ' ' + sub_p + sub_3 + ms)
        isF_parameter_11 = QLabel('I' + sub_p + sub_4 + nA)
        isF_parameter_12 = QLabel('T' + sub_on + ' ' + sub_p + sub_4 + ms)
        isF_parameter_13 = QLabel('T' + sub_off + ' ' + sub_p + sub_4 + ms)
        isF_parameter_14 = QLabel('I' + sub_p + sub_5 + nA)
        isF_parameter_15 = QLabel('T' + sub_on + ' ' + sub_p + sub_5 + ms)
        isF_parameter_16 = QLabel('T' + sub_off + ' ' + sub_p + sub_5 + ms)
        isF_parameter_17 = QLabel('scale factor')
        sesynF_parameter_1 = QLabel('G' + sub_0 + mS_cm_2)
        sesynF_parameter_2 = QLabel('G' + sub_p + sub_1 + mS_cm_2)
        sesynF_parameter_3 = QLabel('T' + sub_on + ' ' + sub_p + sub_1 + ms)
        sesynF_parameter_4 = QLabel('T' + sub_off + ' '+ sub_p + sub_1 + ms)
        sesynF_parameter_5 = QLabel('G' + sub_p + sub_2 + mS_cm_2)
        sesynF_parameter_6 = QLabel('T' + sub_on + ' ' + sub_p + sub_2 + ms)
        sesynF_parameter_7 = QLabel('T' + sub_off + ' '+ sub_p + sub_2 + ms)
        sesynF_parameter_8 = QLabel('G' + sub_p + sub_3 + mS_cm_2)
        sesynF_parameter_9 = QLabel('T' + sub_on + ' ' + sub_p + sub_3 + ms)
        sesynF_parameter_10 = QLabel('T' + sub_off + ' ' + sub_p + sub_3 + ms)
        sesynF_parameter_11 = QLabel('G' + sub_p + sub_4 + mS_cm_2)
        sesynF_parameter_12 = QLabel('T' + sub_on + ' ' + sub_p + sub_4 + ms)
        sesynF_parameter_13 = QLabel('T' + sub_off + ' ' + sub_p + sub_4 + ms)
        sesynF_parameter_14 = QLabel('G' + sub_p + sub_5 + mS_cm_2)
        sesynF_parameter_15 = QLabel('T' + sub_on + ' ' + sub_p + sub_5 + ms)
        sesynF_parameter_16 = QLabel('T' + sub_off + ' ' + sub_p + sub_5 + ms)
        sesynF_parameter_17 = QLabel('scale factor')
        sesynF_parameter_18 = QLabel(tau + ms)
        sesynF_parameter_19 = QLabel('std' + sub_max)
        sesynF_parameter_18.setEnabled(False)
        sesynF_parameter_19.setEnabled(False)
        sesynT_parameter_1 = QLabel('G' + sub_0 + mS_cm_2)
        sesynT_parameter_2 = QLabel('G' + sub_p + mS_cm_2)
        sesynT_parameter_3 = QLabel('Duration' + ms)
        sesynT_parameter_4 = QLabel(tau + ms)
        sesynT_parameter_5 = QLabel('std' + sub_max)
        sesynT_parameter_4.setEnabled(False)
        sesynT_parameter_5.setEnabled(False)
        sisynF_parameter_1 = QLabel('G' + sub_0 + mS_cm_2)
        sisynF_parameter_2 = QLabel('G' + sub_p + sub_1 +mS_cm_2)
        sisynF_parameter_3 = QLabel('T' + sub_on + ' ' + sub_p + sub_1 + ms)
        sisynF_parameter_4 = QLabel('T' + sub_off + ' '+ sub_p + sub_1 + ms)
        sisynF_parameter_5 = QLabel('G' + sub_p + sub_2 + mS_cm_2)
        sisynF_parameter_6 = QLabel('T' + sub_on + ' ' + sub_p + sub_2 + ms)
        sisynF_parameter_7 = QLabel('T' + sub_off + ' '+ sub_p + sub_2 + ms)
        sisynF_parameter_8 = QLabel('G' + sub_p + sub_3 + mS_cm_2)
        sisynF_parameter_9 = QLabel('T' + sub_on + ' ' + sub_p + sub_3 + ms)
        sisynF_parameter_10 = QLabel('T' + sub_off + ' ' + sub_p + sub_3 + ms)
        sisynF_parameter_11 = QLabel('G' + sub_p + sub_4 + mS_cm_2)
        sisynF_parameter_12 = QLabel('T' + sub_on + ' ' + sub_p + sub_4 + ms)
        sisynF_parameter_13 = QLabel('T' + sub_off + ' ' + sub_p + sub_4 + ms)
        sisynF_parameter_14 = QLabel('G' + sub_p + sub_5 + mS_cm_2)
        sisynF_parameter_15 = QLabel('T' + sub_on + ' ' + sub_p + sub_5 + ms)
        sisynF_parameter_16 = QLabel('T' + sub_off + ' ' + sub_p + sub_5 + ms)
        sisynF_parameter_17 = QLabel('scale factor')
        sisynF_parameter_18 = QLabel(tau + ms)
        sisynF_parameter_19 = QLabel('std' + sub_max)
        sisynF_parameter_18.setEnabled(False)
        sisynF_parameter_19.setEnabled(False)
        sisynT_parameter_1 = QLabel('G' + sub_0 + mS_cm_2)
        sisynT_parameter_2 = QLabel('G' + sub_p + mS_cm_2)
        sisynT_parameter_3 = QLabel('Duration' + ms)
        sisynT_parameter_4 = QLabel(tau + ms)
        sisynT_parameter_5 = QLabel('std' + sub_max)
        sisynT_parameter_4.setEnabled(False)
        sisynT_parameter_5.setEnabled(False)
        desynF_parameter_1 = QLabel('G' + sub_0 + mS_cm_2)
        desynF_parameter_2 = QLabel('G' + sub_p + sub_1 +mS_cm_2)
        desynF_parameter_3 = QLabel('T' + sub_on + ' ' + sub_p + sub_1 + ms)
        desynF_parameter_4 = QLabel('T' + sub_off + ' '+ sub_p + sub_1 + ms)
        desynF_parameter_5 = QLabel('G' + sub_p + sub_2 + mS_cm_2)
        desynF_parameter_6 = QLabel('T' + sub_on + ' ' + sub_p + sub_2 + ms)
        desynF_parameter_7 = QLabel('T' + sub_off + ' '+ sub_p + sub_2 + ms)
        desynF_parameter_8 = QLabel('G' + sub_p + sub_3 + mS_cm_2)
        desynF_parameter_9 = QLabel('T' + sub_on + ' ' + sub_p + sub_3 + ms)
        desynF_parameter_10 = QLabel('T' + sub_off + ' ' + sub_p + sub_3 + ms)
        desynF_parameter_11 = QLabel('G' + sub_p + sub_4 + mS_cm_2)
        desynF_parameter_12 = QLabel('T' + sub_on + ' ' + sub_p + sub_4 + ms)
        desynF_parameter_13 = QLabel('T' + sub_off + ' ' + sub_p + sub_4 + ms)
        desynF_parameter_14 = QLabel('G' + sub_p + sub_5 + mS_cm_2)
        desynF_parameter_15 = QLabel('T' + sub_on + ' ' + sub_p + sub_5 + ms)
        desynF_parameter_16 = QLabel('T' + sub_off + ' ' + sub_p + sub_5 + ms)
        desynF_parameter_17 = QLabel('scale factor')
        desynF_parameter_18 = QLabel(tau + ms)
        desynF_parameter_19 = QLabel('std' + sub_max)
        desynF_parameter_18.setEnabled(False)
        desynF_parameter_19.setEnabled(False)
        desynT_parameter_1 = QLabel('G' + sub_0 + mS_cm_2)
        desynT_parameter_2 = QLabel('G' + sub_p + mS_cm_2)
        desynT_parameter_3 = QLabel('Duration' + ms)
        desynT_parameter_4 = QLabel(tau + ms)
        desynT_parameter_5 = QLabel('std' + sub_max)
        desynT_parameter_4 = QLabel(tau + ms)
        desynT_parameter_5 = QLabel('std' + sub_max)
        desynT_parameter_4.setEnabled(False)
        desynT_parameter_5.setEnabled(False)
        disynF_parameter_1 = QLabel('G' + sub_0 + mS_cm_2)
        disynF_parameter_2 = QLabel('G' + sub_p + sub_1 +mS_cm_2)
        disynF_parameter_3 = QLabel('T' + sub_on + ' ' + sub_p + sub_1 + ms)
        disynF_parameter_4 = QLabel('T' + sub_off + ' '+ sub_p + sub_1 + ms)
        disynF_parameter_5 = QLabel('G' + sub_p + sub_2 + mS_cm_2)
        disynF_parameter_6 = QLabel('T' + sub_on + ' ' + sub_p + sub_2 + ms)
        disynF_parameter_7 = QLabel('T' + sub_off + ' '+ sub_p + sub_2 + ms)
        disynF_parameter_8 = QLabel('G' + sub_p + sub_3 + mS_cm_2)
        disynF_parameter_9 = QLabel('T' + sub_on + ' ' + sub_p + sub_3 + ms)
        disynF_parameter_10 = QLabel('T' + sub_off + ' ' + sub_p + sub_3 + ms)
        disynF_parameter_11 = QLabel('G' + sub_p + sub_4 + mS_cm_2)
        disynF_parameter_12 = QLabel('T' + sub_on + ' ' + sub_p + sub_4 + ms)
        disynF_parameter_13 = QLabel('T' + sub_off + ' ' + sub_p + sub_4 + ms)
        disynF_parameter_14 = QLabel('G' + sub_p + sub_5 + mS_cm_2)
        disynF_parameter_15 = QLabel('T' + sub_on + ' ' + sub_p + sub_5 + ms)
        disynF_parameter_16 = QLabel('T' + sub_off + ' ' + sub_p + sub_5 + ms)
        disynF_parameter_17 = QLabel('scale factor')
        disynF_parameter_18 = QLabel(tau + ms)
        disynF_parameter_19 = QLabel('std' + sub_max)
        disynF_parameter_18.setEnabled(False)
        disynF_parameter_19.setEnabled(False)
        disynT_parameter_1 = QLabel('G' + sub_0 + mS_cm_2)
        disynT_parameter_2 = QLabel('G' + sub_p + mS_cm_2)
        disynT_parameter_3 = QLabel('Duration' + ms)
        disynT_parameter_4 = QLabel(tau + ms)
        disynT_parameter_5 = QLabel('std' + sub_max)
        disynT_parameter_4.setEnabled(False)
        disynT_parameter_5.setEnabled(False)
        
        isF_parameter = []
        isF_parameter.append(isF_parameter_1)
        isF_parameter.append(isF_parameter_2)
        isF_parameter.append(isF_parameter_3)
        isF_parameter.append(isF_parameter_4)
        isF_parameter.append(isF_parameter_5)
        isF_parameter.append(isF_parameter_6)
        isF_parameter.append(isF_parameter_7)
        isF_parameter.append(isF_parameter_8)
        isF_parameter.append(isF_parameter_9)
        isF_parameter.append(isF_parameter_10)
        isF_parameter.append(isF_parameter_11)
        isF_parameter.append(isF_parameter_12)
        isF_parameter.append(isF_parameter_13)
        isF_parameter.append(isF_parameter_14)
        isF_parameter.append(isF_parameter_15)
        isF_parameter.append(isF_parameter_16)
        isF_parameter.append(isF_parameter_17)
        sesynF_parameter = []
        sesynF_parameter.append(sesynF_parameter_1)
        sesynF_parameter.append(sesynF_parameter_2)
        sesynF_parameter.append(sesynF_parameter_3)
        sesynF_parameter.append(sesynF_parameter_4)
        sesynF_parameter.append(sesynF_parameter_5)
        sesynF_parameter.append(sesynF_parameter_6)
        sesynF_parameter.append(sesynF_parameter_7)
        sesynF_parameter.append(sesynF_parameter_8)
        sesynF_parameter.append(sesynF_parameter_9)
        sesynF_parameter.append(sesynF_parameter_10)
        sesynF_parameter.append(sesynF_parameter_11)
        sesynF_parameter.append(sesynF_parameter_12)
        sesynF_parameter.append(sesynF_parameter_13)
        sesynF_parameter.append(sesynF_parameter_14)
        sesynF_parameter.append(sesynF_parameter_15)
        sesynF_parameter.append(sesynF_parameter_16)
        sesynF_parameter.append(sesynF_parameter_17)
        sesynF_parameter.append(sesynF_parameter_18)
        sesynF_parameter.append(sesynF_parameter_19)
        sesynT_parameter = []
        sesynT_parameter.append(sesynT_parameter_1)
        sesynT_parameter.append(sesynT_parameter_2)
        sesynT_parameter.append(sesynT_parameter_3)
        sesynT_parameter.append(sesynT_parameter_4)
        sesynT_parameter.append(sesynT_parameter_5)
        sisynF_parameter = []
        sisynF_parameter.append(sisynF_parameter_1)
        sisynF_parameter.append(sisynF_parameter_2)
        sisynF_parameter.append(sisynF_parameter_3)
        sisynF_parameter.append(sisynF_parameter_4)
        sisynF_parameter.append(sisynF_parameter_5)
        sisynF_parameter.append(sisynF_parameter_6)
        sisynF_parameter.append(sisynF_parameter_7)
        sisynF_parameter.append(sisynF_parameter_8)
        sisynF_parameter.append(sisynF_parameter_9)
        sisynF_parameter.append(sisynF_parameter_10)
        sisynF_parameter.append(sisynF_parameter_11)
        sisynF_parameter.append(sisynF_parameter_12)
        sisynF_parameter.append(sisynF_parameter_13)
        sisynF_parameter.append(sisynF_parameter_14)
        sisynF_parameter.append(sisynF_parameter_15)
        sisynF_parameter.append(sisynF_parameter_16)
        sisynF_parameter.append(sisynF_parameter_17)
        sisynF_parameter.append(sisynF_parameter_18)
        sisynF_parameter.append(sisynF_parameter_19)
        sisynT_parameter = []
        sisynT_parameter.append(sisynT_parameter_1)
        sisynT_parameter.append(sisynT_parameter_2)
        sisynT_parameter.append(sisynT_parameter_3)
        sisynT_parameter.append(sisynT_parameter_4)
        sisynT_parameter.append(sisynT_parameter_5)
        desynF_parameter = []
        desynF_parameter.append(desynF_parameter_1)
        desynF_parameter.append(desynF_parameter_2)
        desynF_parameter.append(desynF_parameter_3)
        desynF_parameter.append(desynF_parameter_4)
        desynF_parameter.append(desynF_parameter_5)
        desynF_parameter.append(desynF_parameter_6)
        desynF_parameter.append(desynF_parameter_7)
        desynF_parameter.append(desynF_parameter_8)
        desynF_parameter.append(desynF_parameter_9)
        desynF_parameter.append(desynF_parameter_10)
        desynF_parameter.append(desynF_parameter_11)
        desynF_parameter.append(desynF_parameter_12)
        desynF_parameter.append(desynF_parameter_13)
        desynF_parameter.append(desynF_parameter_14)
        desynF_parameter.append(desynF_parameter_15)
        desynF_parameter.append(desynF_parameter_16)
        desynF_parameter.append(desynF_parameter_17)
        desynF_parameter.append(desynF_parameter_18)
        desynF_parameter.append(desynF_parameter_19)
        desynT_parameter = []
        desynT_parameter.append(desynT_parameter_1)
        desynT_parameter.append(desynT_parameter_2)
        desynT_parameter.append(desynT_parameter_3)
        desynT_parameter.append(desynT_parameter_4)
        desynT_parameter.append(desynT_parameter_5)
        disynF_parameter = []
        disynF_parameter.append(disynF_parameter_1)
        disynF_parameter.append(disynF_parameter_2)
        disynF_parameter.append(disynF_parameter_3)
        disynF_parameter.append(disynF_parameter_4)
        disynF_parameter.append(disynF_parameter_5)
        disynF_parameter.append(disynF_parameter_6)
        disynF_parameter.append(disynF_parameter_7)
        disynF_parameter.append(disynF_parameter_8)
        disynF_parameter.append(disynF_parameter_9)
        disynF_parameter.append(disynF_parameter_10)
        disynF_parameter.append(disynF_parameter_11)
        disynF_parameter.append(disynF_parameter_12)
        disynF_parameter.append(disynF_parameter_13)
        disynF_parameter.append(disynF_parameter_14)
        disynF_parameter.append(disynF_parameter_15)
        disynF_parameter.append(disynF_parameter_16)
        disynF_parameter.append(disynF_parameter_17)
        disynF_parameter.append(disynF_parameter_18)
        disynF_parameter.append(disynF_parameter_19)
        disynT_parameter = []
        disynT_parameter.append(disynT_parameter_1)
        disynT_parameter.append(disynT_parameter_2)
        disynT_parameter.append(disynT_parameter_3)
        disynT_parameter.append(disynT_parameter_4)
        disynT_parameter.append(disynT_parameter_5)

        ## tableWidget
        # row, column
        self.isF_idx = len(isF_parameter)
        self.uid.tableWidget_isF.setColumnCount(3)
        self.uid.tableWidget_isF.setRowCount(self.isF_idx)
        
        col_num = 3
        iter_num = len(self.syn_tableWidget_F)
        for i in range(iter_num):
            self.syn_tableWidget_F[i].setColumnCount(col_num)
            self.syn_tableWidget_F[i].setRowCount(len(self.synF_setValue[i]))
        
        iter_num = len(self.syn_tableWidget_T)
        for i in range(iter_num):
            self.syn_tableWidget_T[i].setColumnCount(col_num)
            self.syn_tableWidget_T[i].setRowCount(len(self.synT_setValue[i]))
        
        # column width
        iter_num = len(self.syn_tableWidget_F)
        for i in range(iter_num):
            tableWidget_header = self.syn_tableWidget_F[i].horizontalHeader()
            tableWidget_header.setDefaultSectionSize(85) 
        
        iter_num = len(self.syn_tableWidget_T)
        for i in range(iter_num):
            tableWidget_header = self.syn_tableWidget_T[i].horizontalHeader()
            tableWidget_header.setDefaultSectionSize(90)    
        
        # parameter lebel
        for i in range(self.isF_idx):
            self.uid.tableWidget_isF.setCellWidget(i, 0, isF_parameter[i])
        synF_idx = len(sesynF_parameter)
        synT_idx = len(sesynT_parameter)
        
        for i in range(synF_idx):
            self.uid.tableWidget_sesynF.setCellWidget(i, 0, sesynF_parameter[i])
            self.uid.tableWidget_sisynF.setCellWidget(i, 0, sisynF_parameter[i])
            self.uid.tableWidget_desynF.setCellWidget(i, 0, desynF_parameter[i])
            self.uid.tableWidget_disynF.setCellWidget(i, 0, disynF_parameter[i])
        
        for i in range(synT_idx):
            self.uid.tableWidget_sesynT.setCellWidget(i, 0, sesynT_parameter[i])
            self.uid.tableWidget_sisynT.setCellWidget(i, 0, sisynT_parameter[i])
            self.uid.tableWidget_desynT.setCellWidget(i, 0, desynT_parameter[i])
            self.uid.tableWidget_disynT.setCellWidget(i, 0, disynT_parameter[i])
        
        # deactivation cell
        for i in range(self.isF_idx):
            item = QTableWidgetItem()
            item.setFlags(Qt.ItemIsEnabled)
            self.uid.tableWidget_isF.setItem(i, 2, item)
        
        iter_num = syn_num 
        idx = syn_idx
        syn_tableWidget = np.asarray(zip(self.syn_tableWidget_F + self.syn_tableWidget_T)).flatten()
        k = 0
        for i in range(iter_num):
            item = QTableWidgetItem()
            item.setFlags(Qt.ItemIsEnabled)
            syn_tableWidget[k].setItem(i-idx[k], 2, item)
            if(i == idx[k+1]-1):
                k+=1
        
        # lineEdit
        self.lineEdit = []
        self.lineEdit.append(self.uid.lineEdit_1)        
        self.lineEdit.append(self.uid.lineEdit_2)
        self.lineEdit.append(self.uid.lineEdit_3)
        self.lineEdit.append(self.uid.lineEdit_4)
        self.lineEdit.append(self.uid.lineEdit_5)
        self.lineEdit.append(self.uid.lineEdit_6)
        self.lineEdit.append(self.uid.lineEdit_7)
        self.lineEdit.append(self.uid.lineEdit_8)
        self.lineEdit.append(self.uid.lineEdit_9)
        self.lineEdit.append(self.uid.lineEdit_10)
        self.lineEdit.append(self.uid.lineEdit_11)
        self.lineEdit.append(self.uid.lineEdit_12)
        
        # checkbox
        self.checkBox = []
        self.checkBox.append(self.uid.checkBox_1)
        self.checkBox.append(self.uid.checkBox_2)
        self.checkBox.append(self.uid.checkBox_3)
        self.checkBox.append(self.uid.checkBox_4)
        self.checkBox.append(self.uid.checkBox_5)
        self.checkBox.append(self.uid.checkBox_6)
        self.checkBox.append(self.uid.checkBox_7)
        self.checkBox.append(self.uid.checkBox_8)
        self.checkBox.append(self.uid.checkBox_9)
        self.checkBox.append(self.uid.checkBox_10)
        self.checkBox.append(self.uid.checkBox_11)
        self.checkBox.append(self.uid.checkBox_12)
        
        # initial value for velocity of Xm
        self.uid.lineEdit_8.setText(str(self.setTable[7]))
        self.uid.lineEdit_9.setText(str(self.setTable[8]))
        self.uid.lineEdit_10.setText(str(self.setTable[9]))
        self.uid.lineEdit_11.setText(str(self.setTable[10]))
        self.uid.lineEdit_12.setText(str(self.setTable[11]))
        
        # set button
        self.isSetButton = self.isFixBtn
        syn_SeSetButton = syn_SeFixBtn
        syn_SiSetButton = syn_SiFixBtn
        syn_DeSetButton = syn_DeFixBtn
        syn_DiSetButton = syn_DiFixBtn     
        self.syn_setButton = [syn_SeSetButton, syn_SiSetButton, syn_DeSetButton, syn_DiSetButton]
        self.spSetButton = self.spUserBtn
        self.xmSetButton = self.xmIsomeBtn
        self.sesyn_setNoise = False
        self.sisyn_setNoise = False
        self.desyn_setNoise = False
        self.disyn_setNoise = False
        
        # set button activation
        self.isSetButton.setChecked(True)
        syn_SeSetButton.setChecked(True)
        syn_SiSetButton.setChecked(True)
        syn_DeSetButton.setChecked(True)
        syn_DiSetButton.setChecked(True)
        self.spSetButton.setChecked(True)
        self.xmSetButton.setChecked(True)
        self.sesyn_noise.setChecked(self.sesyn_setNoise)
        self.sisyn_noise.setChecked(self.sisyn_setNoise)
        self.desyn_noise.setChecked(self.desyn_setNoise)
        self.disyn_noise.setChecked(self.disyn_setNoise)
        
        # initial deactivation
        self.uid.applyButton.setEnabled(False)
        self.uid.okButton.setEnabled(False)
        self.uid.label_1.setEnabled(False)
        self.uid.label_2.setEnabled(False)
        self.uid.label_3.setEnabled(False)
        self.lineEdit[0].setEnabled(False)
        self.lineEdit[1].setEnabled(False)
        self.lineEdit[2].setEnabled(False)
        self.checkBox[0].setEnabled(False)
        self.checkBox[1].setEnabled(False)
        self.checkBox[2].setEnabled(False)
        self.uid.is_lineEdit.setEnabled(False)
        self.uid.is_load_pushButton.setEnabled(False)
        self.uid.tableWidget_sesynT.setEnabled(False)
        self.uid.sesyn_lineEdit.setEnabled(False)
        self.uid.sesyn_load_pushButton.setEnabled(False)
        self.uid.tableWidget_sisynT.setEnabled(False)
        self.uid.sisyn_lineEdit.setEnabled(False)
        self.uid.sisyn_load_pushButton.setEnabled(False)
        self.uid.tableWidget_desynT.setEnabled(False)
        self.uid.desyn_lineEdit.setEnabled(False)
        self.uid.desyn_load_pushButton.setEnabled(False)
        self.uid.tableWidget_disynT.setEnabled(False)
        self.uid.disyn_lineEdit.setEnabled(False)
        self.uid.disyn_load_pushButton.setEnabled(False)
        self.uid.sp_lineEdit.setEnabled(False)
        self.uid.sp_load_pushButton.setEnabled(False)
        self.uid.label_10.setEnabled(False)
        self.uid.label_11.setEnabled(False)
        self.uid.label_12.setEnabled(False)
        self.uid.label_13.setEnabled(False)
        self.uid.label_14.setEnabled(False)
        self.uid.velocity_label.setEnabled(False)
        self.checkBox[8].setEnabled(False)
        self.checkBox[9].setEnabled(False)
        self.checkBox[10].setEnabled(False)
        self.checkBox[11].setEnabled(False)
        self.lineEdit[8].setEnabled(False)
        self.lineEdit[9].setEnabled(False)
        self.lineEdit[10].setEnabled(False)
        self.lineEdit[11].setEnabled(False)
        self.uid.xm_lineEdit.setEnabled(False)
        self.uid.xm_load_pushButton.setEnabled(False)
        
        # GUI operation-function 
        self.uid.buttonBox.connect(self.uid.buttonBox, SIGNAL("accepted()"), self.setValue)
        self.uid.buttonBox.connect(self.uid.applyButton, SIGNAL("clicked()"), self.setValue)
        self.uid.is_load_pushButton.clicked.connect(self.openFile)
        self.uid.sesyn_load_pushButton.clicked.connect(self.openFile)
        self.uid.sisyn_load_pushButton.clicked.connect(self.openFile)
        self.uid.desyn_load_pushButton.clicked.connect(self.openFile)
        self.uid.disyn_load_pushButton.clicked.connect(self.openFile)
        self.uid.sp_load_pushButton.clicked.connect(self.openFile)
        self.uid.xm_load_pushButton.clicked.connect(self.openFile)
        self.uid.generate_pushButton.clicked.connect(self.genSignal)
        self.isFixBtn.clicked.connect(self.setObjectEnabled)
        self.isTriBtn.clicked.connect(self.setObjectEnabled)
        self.isImtBtn.clicked.connect(self.setObjectEnabled)
        syn_SeFixBtn.clicked.connect(self.setObjectEnabled)
        syn_SeTriBtn.clicked.connect(self.setObjectEnabled)
        syn_SeImtBtn.clicked.connect(self.setObjectEnabled)
        syn_SiFixBtn.clicked.connect(self.setObjectEnabled)
        syn_SiTriBtn.clicked.connect(self.setObjectEnabled)
        syn_SiImtBtn.clicked.connect(self.setObjectEnabled)
        syn_DeFixBtn.clicked.connect(self.setObjectEnabled)
        syn_DeTriBtn.clicked.connect(self.setObjectEnabled)
        syn_DeImtBtn.clicked.connect(self.setObjectEnabled)
        syn_DiFixBtn.clicked.connect(self.setObjectEnabled)
        syn_DiTriBtn.clicked.connect(self.setObjectEnabled)
        syn_DiImtBtn.clicked.connect(self.setObjectEnabled)
        self.spUserBtn.clicked.connect(self.setObjectEnabled)
        self.spExpBtn.clicked.connect(self.setObjectEnabled)
        self.xmIsomeBtn.clicked.connect(self.setObjectEnabled)
        self.xmIsokiBtn.clicked.connect(self.setObjectEnabled)
        self.xmDyBtn.clicked.connect(self.setObjectEnabled)
        self.xmExpBtn.clicked.connect(self.setObjectEnabled)
        self.uid.lineEdit_1.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_2.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_3.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_4.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_5.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_6.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_7.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_8.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_9.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_10.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_11.editingFinished.connect(self.checkValue)
        self.uid.lineEdit_12.editingFinished.connect(self.checkValue)
        self.uid.tableWidget_isF.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_sesynF.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_sisynF.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_desynF.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_disynF.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_sesynT.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_sisynT.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_desynT.cellChanged.connect(self.checkValue)
        self.uid.tableWidget_disynT.cellChanged.connect(self.checkValue)
        self.uid.lineEdit_9.editingFinished.connect(self.calXmVelocity)
        self.uid.lineEdit_10.editingFinished.connect(self.calXmVelocity)
        self.uid.lineEdit_11.editingFinished.connect(self.calXmVelocity)
        self.uid.lineEdit_12.editingFinished.connect(self.calXmVelocity)
        self.uid.checkBox_1.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_2.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_3.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_4.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_5.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_6.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_7.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_8.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_9.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_10.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_11.stateChanged.connect(self.returnDefaultValue)
        self.uid.checkBox_12.stateChanged.connect(self.returnDefaultValue)
        self.uid.tableWidget_isF.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_sesynF.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_sisynF.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_desynF.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_disynF.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_sesynT.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_sisynT.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_desynT.cellClicked.connect(self.returnDefaultValue)
        self.uid.tableWidget_disynT.cellClicked.connect(self.returnDefaultValue)
        self.sesyn_noise.stateChanged.connect(self.setObjectEnabled)
        self.sisyn_noise.stateChanged.connect(self.setObjectEnabled)
        self.desyn_noise.stateChanged.connect(self.setObjectEnabled)
        self.disyn_noise.stateChanged.connect(self.setObjectEnabled)

    def keyPressEvent(self, event):
        # operation of Key_Return or Key_Enter
        if(event.key() == 0x01000005 or event.key() == 0x01000004):
            for i in range(len(self.lineEdit)):            
                self.lineEdit[i].clearFocus()
        else:
            # QDialog event
            super(SignalGeneratorWindow, self).keyPressEvent(event)

    def checkValue(self, row=0, col=3):
        # tableWidget
        if(col == 1):
            tableWidget = self.sender()
                        
            if(tableWidget == self.uid.tableWidget_isF):
                item = self.uid.tableWidget_isF.item(row, col)
                defValue = self.isF_defValue[row]
                setValue = self.isF_setValue[row]
            
            for i in range(len(self.syn_tableWidget_F)):
                if(tableWidget == self.syn_tableWidget_F[i]):
                    item = tableWidget.item(row, col)
                    defValue = self.synF_defValue[i][row]
                    setValue = self.synF_setValue[i][row]
            
            for i in range(len(self.syn_tableWidget_T)):
                if(tableWidget == self.syn_tableWidget_T[i]):
                    item = tableWidget.item(row, col)
                    defValue = self.synT_defValue[i][row]
                    setValue = self.synT_setValue[i][row]
            
            try:                
                # compare with default value
                if(round(float(item.text()), 10) != round(defValue, 10)):
                    item = QTableWidgetItem()
                    icon = QIcon()
                    icon.addPixmap(QPixmap("./resources/default.png"))
                    item.setIcon(icon)
                    item.setFlags(Qt.ItemIsEnabled)
                    tableWidget.setItem(row, 2, item)
                else:
                    item = QTableWidgetItem()
                    item.setFlags(Qt.ItemIsEnabled)  
                    tableWidget.setItem(row, 2, item)
            
            except:
                item = QTableWidgetItem(str(setValue))
                tableWidget.setItem(row, 1, item)
        
        # lineEdit
        elif(col == 3):
            # compare with default value
            for i in range(self.default_num):
                try:
                    if(round(float(self.lineEdit[i].text()), 10) != round(self.defaultTable[i], 10)):
                        self.checkBox[i].setCheckState(Qt.Checked)
                        self.checkBox[i].setEnabled(True)
                        self.setObjectEnabled() 
                    else:
                        self.checkBox[i].setCheckState(Qt.Unchecked)
                        self.checkBox[i].setEnabled(False)
                
                except:
                    self.lineEdit[i].setText(str(self.setTable[i]))
    
    def returnDefaultValue(self, row=0, col=3):
        # tableWidget
        if(col == 2):
            tableWidget = self.sender()
            
            if(tableWidget == self.uid.tableWidget_isF):
                defValue = self.isF_defValue
                item = QTableWidgetItem(str(defValue[row]))
                tableWidget.setItem(row, 1, item)
            
            for i in range(len(self.syn_tableWidget_F)):
                if(tableWidget == self.syn_tableWidget_F[i]):
                    # prevent return value of SynCon noise parameters that is deactivated.
                    if(row == 17 or row == 18):
                        if(not self.syn_noise[i].isChecked()):
                            continue
                    # return the default value        
                    item = QTableWidgetItem(str(self.synF_defValue[i][row]))
                    self.syn_tableWidget_F[i].setItem(row, 1, item)
            
            for i in range(len(self.syn_tableWidget_T)):
                if(tableWidget == self.syn_tableWidget_T[i]):
                    # prevent return value of SynCon noise parameters that is deactivated.
                    if(row == 3 or row == 4):
                        if(not self.syn_noise[i].isChecked()):
                            continue                    
                    # return the default value   
                    item = QTableWidgetItem(str(self.synT_defValue[i][row]))
                    self.syn_tableWidget_T[i].setItem(row, 1, item)
        
        # lineEdit
        elif(col == 3):
            checkBox = self.sender()
            
            if(not checkBox.isChecked()):
                # find checkBox index
                for i in range(self.default_num):
                    if(self.checkBox[i] == checkBox):
                        break
                
                # return the default value    
                self.lineEdit[i].setText(str(self.defaultTable[i]))
                self.checkBox[i].setEnabled(False)
                # prevent widget focus
                if((i+1) < self.default_num):
                    self.lineEdit[i+1].clearFocus()            
            
    def setItemColorEnable(self, tableWidget, row, col, color, enable):
        # change tau, std_max label color according to noise checkbox
        # to inform activation or deactivation of value.
        item_v = tableWidget.item(row, col)
        item = QTableWidgetItem(item_v.text())
        item.setTextColor(color)
        
        if(enable == True):
            item.setFlags(item.flags() | Qt.ItemIsEnabled)
        else:
            item.setFlags(item.flags() & Qt.ItemIsEnabled)
        
        tableWidget.setItem(row, col, item)
    
    def setObjectEnabled(self):
        ## object enable setting
        # Isoma
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):
            if(self.isFixBtn.isChecked()):
                self.uid.tableWidget_isF.setEnabled(True)
                self.uid.label_1.setEnabled(False)
                self.uid.label_2.setEnabled(False)
                self.uid.label_3.setEnabled(False)
                self.lineEdit[0].setEnabled(False)
                self.lineEdit[1].setEnabled(False)
                self.lineEdit[2].setEnabled(False)
                self.checkBox[0].setEnabled(False)
                self.checkBox[1].setEnabled(False)
                self.checkBox[2].setEnabled(False)
                self.uid.is_lineEdit.setEnabled(False)
                self.uid.is_load_pushButton.setEnabled(False)
            
            elif(self.isTriBtn.isChecked()):
                self.uid.label_1.setEnabled(True)
                self.uid.label_2.setEnabled(True)
                self.uid.label_3.setEnabled(True)
                if(self.checkBox[0].isChecked()):
                    self.checkBox[0].setEnabled(True)
                if(self.checkBox[1].isChecked()):
                    self.checkBox[1].setEnabled(True)
                if(self.checkBox[2].isChecked()):
                    self.checkBox[2].setEnabled(True)
                self.lineEdit[0].setEnabled(True)
                self.lineEdit[1].setEnabled(True)
                self.lineEdit[2].setEnabled(True)
                self.uid.tableWidget_isF.setEnabled(False)
                self.uid.is_lineEdit.setEnabled(False)
                self.uid.is_load_pushButton.setEnabled(False)
            
            elif(self.isImtBtn.isChecked()):
                self.uid.is_lineEdit.setEnabled(True)
                self.uid.is_load_pushButton.setEnabled(True)
                self.uid.label_1.setEnabled(False)
                self.uid.label_2.setEnabled(False)
                self.uid.label_3.setEnabled(False)
                self.lineEdit[0].setEnabled(False)
                self.lineEdit[1].setEnabled(False)
                self.lineEdit[2].setEnabled(False)
                self.checkBox[0].setEnabled(False)
                self.checkBox[1].setEnabled(False)
                self.checkBox[2].setEnabled(False)
                self.uid.tableWidget_isF.setEnabled(False)
            
            # Isyn
            tau = u'\u03C4'
            ms = ' (ms)'
            sub_max = '<sub>max</sub>'
            rowF = 17
            rowT = 3
            v_col = 1
            l_col = 0
            channel_enable = range(4)
            if(self.MW.PSW.channel_enable['Sesyn'] == True):
                channel_enable[0] = True
            else:
                channel_enable[0] = False
            if(self.MW.PSW.channel_enable['Sisyn'] == True):
                channel_enable[1] = True
            else:
                channel_enable[1] = False
            if(self.MW.PSW.channel_enable['Desyn'] == True):
                channel_enable[2] = True
            else:
                channel_enable[2] = False
            if(self.MW.PSW.channel_enable['Disyn'] == True):
                channel_enable[3] = True
            else:
                channel_enable[3] = False
            
            for i in range(len(channel_enable)):
                if(channel_enable[i] == True):
                    self.syn_ch[i] = True
                    self.groupBox_syn[i].setEnabled(True)
                    label_1 = QLabel(tau + ms)
                    label_2 = QLabel('std' + sub_max)
                    label_3 = QLabel(tau + ms)
                    label_4 = QLabel('std' + sub_max)
                    
                    if(self.syn_FixBtn[i].isChecked()):
                        self.syn_noise[i].setEnabled(True)
                        self.syn_tableWidget_F[i].setEnabled(True)
                        self.syn_tableWidget_T[i].setEnabled(False)
                        self.syn_lineEdit[i].setEnabled(False)
                        self.syn_load_pushButton[i].setEnabled(False)
                        act_colorF = Qt.black
                        act_colorT = Qt.darkGray
                        de_colorF = Qt.darkGray
                        de_colorT = Qt.darkGray
                    
                    elif(self.syn_TriBtn[i].isChecked()):
                        self.syn_noise[i].setEnabled(True)
                        self.syn_tableWidget_F[i].setEnabled(False)
                        self.syn_tableWidget_T[i].setEnabled(True)
                        self.syn_lineEdit[i].setEnabled(False)
                        self.syn_load_pushButton[i].setEnabled(False)
                        act_colorF = Qt.darkGray
                        act_colorT = Qt.black
                        de_colorF = Qt.darkGray
                        de_colorT = Qt.darkGray
                    
                    elif(self.syn_ImtBtn[i].isChecked()):
                        self.syn_noise[i].setEnabled(False)
                        self.syn_tableWidget_F[i].setEnabled(False)
                        self.syn_tableWidget_T[i].setEnabled(False)
                        self.syn_lineEdit[i].setEnabled(True)
                        self.syn_load_pushButton[i].setEnabled(True)
                        act_colorF = Qt.darkGray
                        act_colorT = Qt.darkGray
                        de_colorF = Qt.darkGray
                        de_colorT = Qt.darkGray
                    
                    if(self.syn_noise[i].isChecked()):
                        label_1.setEnabled(True)
                        label_2.setEnabled(True)
                        label_3.setEnabled(True)
                        label_4.setEnabled(True)
                        self.setItemColorEnable(self.syn_tableWidget_F[i], rowF,   v_col, act_colorF, True)
                        self.setItemColorEnable(self.syn_tableWidget_F[i], rowF+1, v_col, act_colorF, True)
                        self.setItemColorEnable(self.syn_tableWidget_T[i], rowT,   v_col, act_colorT, True)
                        self.setItemColorEnable(self.syn_tableWidget_T[i], rowT+1, v_col, act_colorT, True)
                    
                    else:
                        label_1.setEnabled(False)
                        label_2.setEnabled(False)
                        label_3.setEnabled(False)
                        label_4.setEnabled(False)
                        self.setItemColorEnable(self.syn_tableWidget_F[i], rowF,   v_col, de_colorF, False)
                        self.setItemColorEnable(self.syn_tableWidget_F[i], rowF+1, v_col, de_colorF, False)
                        self.setItemColorEnable(self.syn_tableWidget_T[i], rowT,   v_col, de_colorT, False)
                        self.setItemColorEnable(self.syn_tableWidget_T[i], rowT+1, v_col, de_colorT, False)
                    self.syn_tableWidget_F[i].setCellWidget(rowF,   l_col, label_1)
                    self.syn_tableWidget_F[i].setCellWidget(rowF+1, l_col, label_2)
                    self.syn_tableWidget_T[i].setCellWidget(rowT,   l_col, label_3)
                    self.syn_tableWidget_T[i].setCellWidget(rowT+1, l_col, label_4)
                
                else:
                    self.syn_ch[i] = False
                    self.groupBox_syn[i].setEnabled(False)
                    self.syn_noise[i].setEnabled(False)
                    self.setItemColorEnable(self.syn_tableWidget_F[i], rowF,   v_col, Qt.darkGray, False)
                    self.setItemColorEnable(self.syn_tableWidget_F[i], rowF+1, v_col, Qt.darkGray, False)
                    self.setItemColorEnable(self.syn_tableWidget_T[i], rowT,   v_col, Qt.darkGray, False)
                    self.setItemColorEnable(self.syn_tableWidget_T[i], rowT+1, v_col, Qt.darkGray, False)

        if(self.MW.ModelType == 'Muscle Fibers'):
            if(self.spUserBtn.isChecked()):
                self.uid.label_4.setEnabled(True)
                self.uid.label_5.setEnabled(True)
                self.uid.label_6.setEnabled(True)
                self.uid.label_7.setEnabled(True)
                if(self.checkBox[3].isChecked()):
                    self.checkBox[3].setEnabled(True)
                if(self.checkBox[4].isChecked()):  
                    self.checkBox[4].setEnabled(True)
                if(self.checkBox[5].isChecked()):
                    self.checkBox[5].setEnabled(True)
                if(self.checkBox[6].isChecked()):
                    self.checkBox[6].setEnabled(True)
                self.lineEdit[3].setEnabled(True)
                self.lineEdit[4].setEnabled(True)
                self.lineEdit[5].setEnabled(True)
                self.lineEdit[6].setEnabled(True)
                self.uid.sp_lineEdit.setEnabled(False)
                self.uid.sp_load_pushButton.setEnabled(False)
            
            elif(self.spExpBtn.isChecked()):
                self.uid.sp_lineEdit.setEnabled(True)
                self.uid.sp_load_pushButton.setEnabled(True)
                self.uid.label_4.setEnabled(False)
                self.uid.label_5.setEnabled(False)
                self.uid.label_6.setEnabled(False)
                self.uid.label_7.setEnabled(False)
                self.checkBox[3].setEnabled(False)
                self.checkBox[4].setEnabled(False)
                self.checkBox[5].setEnabled(False)
                self.checkBox[6].setEnabled(False)
                self.lineEdit[3].setEnabled(False)
                self.lineEdit[4].setEnabled(False)
                self.lineEdit[5].setEnabled(False)
                self.lineEdit[6].setEnabled(False)
                
        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'):
            if(self.xmIsomeBtn.isChecked()):
                self.uid.label_9.setEnabled(True)
                self.lineEdit[7].setEnabled(True)
                if(self.checkBox[7].isChecked()):
                    self.checkBox[7].setEnabled(True)
                self.uid.label_10.setEnabled(False)
                self.uid.label_11.setEnabled(False)
                self.uid.label_12.setEnabled(False)
                self.uid.label_13.setEnabled(False)
                self.uid.label_14.setEnabled(False)
                self.uid.velocity_label.setEnabled(False)
                self.checkBox[8].setEnabled(False)
                self.checkBox[9].setEnabled(False)
                self.checkBox[10].setEnabled(False)
                self.checkBox[11].setEnabled(False)
                self.lineEdit[8].setEnabled(False)
                self.lineEdit[9].setEnabled(False)
                self.lineEdit[10].setEnabled(False)
                self.lineEdit[11].setEnabled(False)
                self.uid.xm_lineEdit.setEnabled(False)
                self.uid.xm_load_pushButton.setEnabled(False)  
            
            elif(self.xmIsokiBtn.isChecked()):
                self.uid.label_9.setEnabled(False)
                self.lineEdit[7].setEnabled(False)
                self.checkBox[7].setEnabled(False)
                self.uid.label_10.setEnabled(True)
                self.uid.label_11.setEnabled(True)
                self.uid.label_12.setEnabled(True)
                self.uid.label_13.setEnabled(True)
                self.uid.label_14.setEnabled(True)
                self.uid.velocity_label.setEnabled(True)
                if(self.checkBox[8].isChecked()):
                    self.checkBox[8].setEnabled(True)
                if(self.checkBox[9].isChecked()):
                    self.checkBox[9].setEnabled(True)
                if(self.checkBox[10].isChecked()):
                    self.checkBox[10].setEnabled(True)
                if(self.checkBox[11].isChecked()):
                    self.checkBox[11].setEnabled(True)
                self.lineEdit[8].setEnabled(True)
                self.lineEdit[9].setEnabled(True)
                self.lineEdit[10].setEnabled(True)                
                self.lineEdit[11].setEnabled(True)
                self.uid.xm_lineEdit.setEnabled(False)
                self.uid.xm_load_pushButton.setEnabled(False)
            
            elif(self.xmDyBtn.isChecked()):
                self.uid.label_9.setEnabled(False)
                self.lineEdit[7].setEnabled(False)
                self.checkBox[7].setEnabled(False)
                self.uid.label_10.setEnabled(False)
                self.uid.label_11.setEnabled(False)
                self.uid.label_12.setEnabled(False)
                self.uid.label_13.setEnabled(False)
                self.uid.label_14.setEnabled(False)
                self.uid.velocity_label.setEnabled(False)
                self.checkBox[8].setEnabled(False)
                self.checkBox[9].setEnabled(False)
                self.checkBox[10].setEnabled(False)
                self.checkBox[11].setEnabled(False)
                self.lineEdit[8].setEnabled(False)
                self.lineEdit[9].setEnabled(False)
                self.lineEdit[10].setEnabled(False)
                self.lineEdit[11].setEnabled(False)
                self.uid.xm_lineEdit.setEnabled(False)
                self.uid.xm_load_pushButton.setEnabled(False)
            
            elif(self.xmExpBtn.isChecked()):
                self.uid.label_9.setEnabled(False)
                self.lineEdit[7].setEnabled(False)
                self.checkBox[7].setEnabled(False)
                self.uid.label_10.setEnabled(False)
                self.uid.label_11.setEnabled(False)
                self.uid.label_12.setEnabled(False)
                self.uid.label_13.setEnabled(False)
                self.uid.label_14.setEnabled(False)
                self.uid.velocity_label.setEnabled(False)
                self.checkBox[8].setEnabled(False)
                self.checkBox[9].setEnabled(False)
                self.checkBox[10].setEnabled(False)
                self.checkBox[11].setEnabled(False)
                self.lineEdit[8].setEnabled(False)
                self.lineEdit[9].setEnabled(False)
                self.lineEdit[10].setEnabled(False)
                self.lineEdit[11].setEnabled(False)
                self.uid.xm_lineEdit.setEnabled(True)
                self.uid.xm_load_pushButton.setEnabled(True)
            
    def displayValue(self):
        # display set value
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):
            for i in range(self.isF_idx):
                item = QTableWidgetItem(str(self.isF_setValue[i]))
                self.uid.tableWidget_isF.setItem(i, 1, item)
            self.uid.lineEdit_1.setText(str(self.setTable[0]))
            self.uid.lineEdit_2.setText(str(self.setTable[1]))
            self.uid.lineEdit_3.setText(str(self.setTable[2]))
            
            iter_num = self.synF_num 
            idx = self.synF_idx 
            k = 0            
            for i in range(iter_num):
                item = QTableWidgetItem(str(self.synF_setValue[k][i-idx[k]]))
                self.syn_tableWidget_F[k].setItem(i-idx[k], 1, item)
                if(i == idx[k+1]-1):
                    k+=1
            
            iter_num = self.synT_num 
            idx = self.synT_idx
            k = 0            
            for i in range(iter_num):
                item = QTableWidgetItem(str(self.synT_setValue[k][i-idx[k]]))
                self.syn_tableWidget_T[k].setItem(i-idx[k], 1, item)
                if(i == idx[k+1]-1):
                    k+=1
        
        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'):
            if(self.MW.ModelType == 'Muscle Fibers'):
                self.uid.lineEdit_4.setText(str(self.setTable[3]))
                self.uid.lineEdit_5.setText(str(self.setTable[4]))
                self.uid.lineEdit_6.setText(str(self.setTable[5]))
                self.uid.lineEdit_7.setText(str(self.setTable[6]))
            self.uid.lineEdit_8.setText(str(self.setTable[7]))
            self.uid.lineEdit_9.setText(str(self.setTable[8]))
            self.uid.lineEdit_10.setText(str(self.setTable[9]))
            self.uid.lineEdit_11.setText(str(self.setTable[10]))
            self.uid.lineEdit_12.setText(str(self.setTable[11]))
            self.calXmVelocity()
            
        # tab activation or deactivation
        if(self.MW.ModelType == 'Motoneuron'): 
            self.uid.tabWidget.setTabEnabled(0, True)
            self.uid.tabWidget.setTabEnabled(1, True) 
            self.uid.tabWidget.setTabEnabled(2, False)
            self.uid.tabWidget.setTabEnabled(3, False)
            self.uid.tabWidget.setCurrentIndex(0) 
        elif(self.MW.ModelType == 'Muscle Fibers'):
            self.uid.tabWidget.setTabEnabled(0, False)
            self.uid.tabWidget.setTabEnabled(1, False) 
            self.uid.tabWidget.setTabEnabled(2, True)
            self.uid.tabWidget.setTabEnabled(3, True)
            self.uid.tabWidget.setCurrentIndex(2)
        elif(self.MW.ModelType == 'Motor Unit'):
            self.uid.tabWidget.setTabEnabled(0, True)
            self.uid.tabWidget.setTabEnabled(1, True) 
            self.uid.tabWidget.setTabEnabled(2, False)
            self.uid.tabWidget.setTabEnabled(3, True)
            self.uid.tabWidget.setCurrentIndex(0)
            
        # radio button set
        self.isSetButton.setChecked(True)
        for i in range(len(self.syn_setButton)):
            self.syn_setButton[i].setChecked(True)
        self.spSetButton.setChecked(True)
        self.xmSetButton.setChecked(True)
        self.sesyn_noise.setChecked(self.sesyn_setNoise)
        self.sisyn_noise.setChecked(self.sisyn_setNoise)
        self.desyn_noise.setChecked(self.desyn_setNoise)
        self.disyn_noise.setChecked(self.disyn_setNoise)
        self.setObjectEnabled()
        self.checkValue()
        
        # ButtonBox enable
        self.uid.applyButton.setEnabled(False)
        self.uid.okButton.setEnabled(False)

    def calXmVelocity(self):
        # calculate slope from isokinetic Xm according to changing the value
        try:
            t1 = float(self.uid.lineEdit_11.text())
            t1 = self.setTable[10]
            t2 = float(self.uid.lineEdit_12.text())
            t2 = self.setTable[11]
            x1 = float(self.uid.lineEdit_9.text())
            x1 = self.setTable[8]
            x2 = float(self.uid.lineEdit_10.text())
            x2 = self.setTable[9]
            ms = 0.001
            v = (x2-x1)/((t2-t1)*ms)
            self.uid.velocity_label.setText(str(v))    
        
        except:
            self.uid.velocity_label.setText('')
        
    def setValue(self):
        ## set the value
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):
            # Isoma
            if(self.gen_isType == 'Step'):
                self.isF_setValue = self.gen_isF_heav[:]
                self.isSetButton = self.isFixBtn
            elif(self.gen_isType == 'Ramp'):   
                self.setTable[0] = self.gen_is_iValue
                self.setTable[1] = self.gen_is_pValue
                self.setTable[2] = self.gen_is_period
                self.isSetButton = self.isTriBtn
            elif(self.gen_isType == 'Import'):
                self.isSetButton = self.isImtBtn
            
            # Isyn
            # noise checkbox set
            if(self.sesyn_noise.isChecked()):
                self.sesyn_setNoise = True
            else:
                self.sesyn_setNoise = False
            if(self.sisyn_noise.isChecked()):
                self.sisyn_setNoise = True
            else:
                self.sisyn_setNoise = False
            if(self.desyn_noise.isChecked()):
                self.desyn_setNoise = True
            else:
                self.desyn_setNoise = False
            if(self.disyn_noise.isChecked()):
                self.disyn_setNoise = True
            else:
                self.disyn_setNoise = False
            
            for i in range(len(self.gen_synType)):
                if(self.gen_synType[i] == 'Step'):
                    new_arr = [self.gen_synF_tau[i], self.gen_synF_std_max[i]]
                    com_arr = self.gen_synF_heav[i] + new_arr
                    self.synF_setValue[i] = com_arr[:]
                    self.syn_setButton[i] = self.syn_FixBtn[i]
                
                elif(self.gen_synType[i] == 'Ramp'):
                    self.synT_setValue[i] = [self.gen_synT_iValue[i],self.gen_synT_pValue[i],self.gen_synT_period[i],self.gen_synT_tau[i],self.gen_synT_std_max[i]]
                    self.syn_setButton[i] = self.syn_TriBtn[i]
                
                elif(self.gen_synType[i] == 'Import'):
                    self.syn_setButton[i] = self.syn_ImtBtn[i]

        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'): 
            # Iaxon
            if(self.MW.ModelType == 'Muscle Fibers'):
                if(self.gen_spikeType == 'User'):
                    self.setTable[3] = self.gen_spike_t1
                    self.setTable[4] = self.gen_spike_t2
                    self.setTable[5] = self.gen_spike_hz
                    self.setTable[6] = self.gen_spike_scale
                    self.spSetButton = self.spUserBtn
                
                elif(self.gen_spikeType == 'Exp'):
                    self.spSetButton = self.spExpBtn
            # Xm
            if(self.gen_xmType == 'Isometric'):
                self.setTable[7] = self.gen_xm_value
                self.xmSetButton = self.xmIsomeBtn
            
            elif(self.gen_xmType == 'Isokinetic'):
                self.xmSetButton = self.xmIsokiBtn
                self.setTable[8] = self.gen_xm_value1
                self.setTable[9] = self.gen_xm_value2
                self.setTable[10] = self.gen_xm_t1
                self.setTable[11] = self.gen_xm_t2
            
            elif(self.gen_xmType == 'Exp'):
                self.xmSetButton = self.xmExpBtn
            
            elif(self.gen_xmType == 'Dynamic'):
                self.xmSetButton = self.xmDyBtn                
        
        self.t_start, self.t_final, self.t_dt, self.t_pt = self.MW.ISW.t_setTable
        
        # Text message
        if(self.MW.ModelType == 'Motoneuron'):
            self.MW.MN.setInputSignal(self.ISG.signalType, self.ISG.iValue, self.ISG.pValue, self.ISG.Is_0, self.ISG.heav_param, self.ISG.period, self.ISG.times, self.ISG.Is)
            self.MW.MN.setSynConSignal(self.se_ch, self.si_ch, self.de_ch, self.di_ch, self.s_SCSG.e_times, self.s_SCSG.i_times, self.d_SCSG.e_times, self.d_SCSG.i_times, self.s_SCSG.G_e, self.s_SCSG.G_i, self.d_SCSG.G_e, self.d_SCSG.G_i)
            self.MW.setTextEdit("[Motoneuron] Input signals set.")
        elif(self.MW.ModelType == 'Muscle Fibers'):
            self.MW.MF.setSpikeSignal(self.SSG.spike, self.SSG.spike_idx, self.SSG.SpikeTimes)                
            self.MW.MF.setXmSignal(self.XSG.signalType, self.XSG.times, self.XSG.xm)
            self.MW.setTextEdit("[Muscle Fibers] Input signals set.")
        elif(self.MW.ModelType == 'Motor Unit'):
            self.MW.MU.setInputSignal(self.ISG.signalType, self.ISG.iValue, self.ISG.pValue, self.ISG.Is_0, self.ISG.heav_param, self.ISG.period, self.ISG.times, self.ISG.Is)
            self.MW.MU.setSynConSignal(self.se_ch, self.si_ch, self.de_ch, self.di_ch, self.s_SCSG.e_times, self.s_SCSG.i_times, self.d_SCSG.e_times, self.d_SCSG.i_times, self.s_SCSG.G_e, self.s_SCSG.G_i, self.d_SCSG.G_e, self.d_SCSG.G_i)
            self.MW.MU.setXmSignal(self.XSG.signalType, self.XSG.times, self.XSG.xm)
            self.MW.setTextEdit("[Motor Unit] Input signals set.")

        # save tab index
        currentWidget = self.uid.tabWidget.currentWidget()
        if(currentWidget == self.uid.is_tab):
            i = 0
        elif(currentWidget == self.uid.syn_tab):
            i = 1
        elif(currentWidget == self.uid.sp_tab):
            i = 2
        elif(currentWidget == self.uid.xm_tab):
            i = 3

        self.displayValue()
        self.uid.tabWidget.setCurrentIndex(i)

    def openFile(self):
        curPath = os.path.dirname( os.path.abspath( sys.argv[0] ) )
        pushButton = self.sender()
        
        try:
            if(pushButton == self.uid.is_load_pushButton):
                signal = 'Isoma'
            elif(pushButton == self.uid.sesyn_load_pushButton):
                signal = 'G_esyn_soma'
            elif(pushButton == self.uid.sisyn_load_pushButton):
                signal = 'G_isyn_soma'
            elif(pushButton == self.uid.desyn_load_pushButton):
                signal = 'G_esyn_dend'
            elif(pushButton == self.uid.disyn_load_pushButton):
                signal = 'G_isyn_dend'
            elif(pushButton == self.uid.sp_load_pushButton):
                signal = 'Iaxon'
            elif(pushButton == self.uid.xm_load_pushButton):
                signal = 'Xm'
            fileName = QFileDialog.getOpenFileName(self, "Open a " + signal + " data File (Must be a csv format)", curPath+"/parameters", "CSV Files (*.csv)")
        
        except:
            self.MW.setTextEdit("[Error] Failed to open " + signal + "data file.")
            self.MW.raise_()
            self.MW.activateWindow()
        
        if(fileName != ''):
            self.importData(fileName, pushButton, signal)

    def importData(self, fileName, pushButton, signal):
        currentWidget = self.uid.tabWidget.currentWidget()
        
        try:
            data = pd.read_csv(unicode(fileName))
            import_time = np.zeros(len(data.index))
            import_data = np.zeros(len(data.index))
            
            # Isoma
            if(pushButton == self.uid.is_load_pushButton):
                for i in range(len(data.index)):
                    import_time[i] = float(data.time[i])
                    if(math.isnan(import_data[i])):
                        raise Exception
                self.expIs_time = import_time
                
                for i in range(len(data.index)):
                    import_data[i] = float(data.Is[i])
                    if(math.isnan(import_data[i])):
                        raise Exception
                self.expIs = import_data
                self.uid.is_lineEdit.setText(fileName)
            
            # Isyn
            elif(currentWidget == self.uid.syn_tab):
                for i in range(len(self.syn_load_pushButton)):
                    if(pushButton == self.syn_load_pushButton[i]):
                        if(i==0):
                            G = data.G_esyn_soma
                        elif(i==1):
                            G = data.G_isyn_soma
                        elif(i==2):
                            G = data.G_esyn_dend
                        elif(i==3):
                            G = data.G_isyn_dend
                        
                        for k in range(len(data.index)):
                            import_time[k] = float(data.time[k])
                            import_data[k] = float(G[k])
                            if(math.isnan(import_time[k]) and math.isnan(import_data[k])):
                                raise Exception
                        self.exp_syn_time[i] = import_time
                        self.exp_syn[i] = import_data
                        self.syn_lineEdit[i].setText(fileName)
            
            # Iaxon
            elif(pushButton == self.uid.sp_load_pushButton):
                for i in range(len(data.index)):
                    import_data[i] = float(data.time[i])
                self.ExpSpike = import_data
                self.uid.sp_lineEdit.setText(fileName)
            
            # Xm
            elif(pushButton == self.uid.xm_load_pushButton):
                for i in range(len(data.index)):
                    import_time[i] = float(data.time[i])
                    if(math.isnan(import_data[i])):
                        raise Exception
                self.expXm_time = import_time
                
                for i in range(len(data.index)):
                    import_data[i] = float(data.Xm[i])
                    if(math.isnan(import_data[i])):
                        raise Exception
                self.expXm = import_data
                self.uid.xm_lineEdit.setText(fileName) 
        
        except:
            self.MW.setTextEdit("[Error] Failed to load " + signal + " data.")
            self.MW.raise_()
            self.MW.activateWindow()
            return

    def genSignal(self):
        # generate signal
        self.t_start, self.t_final, self.t_dt, self.t_pt = self.MW.ISW.t_setTable
        num_steps = int(np.floor((self.t_final-self.t_start)/self.t_dt)+1) 
        times = np.linspace(self.t_start, self.t_final, num_steps)
        currentWidget = self.uid.tabWidget.currentWidget()
        
        # Isoma
        if(currentWidget == self.uid.is_tab):
            if(self.isFixBtn.isChecked()):
                signalType = 'Step'
                for i in range(len(self.gen_isF_heav)):
                    item = self.uid.tableWidget_isF.item(i, 1)
                    self.gen_isF_heav[i] = float(item.text())
                self.ISG.setValue(signalType, self.t_final, self.t_dt, heav_param=self.gen_isF_heav)
            
            elif(self.isTriBtn.isChecked()): 
                signalType = 'Ramp'
                self.gen_is_iValue = float(self.uid.lineEdit_1.text())
                self.gen_is_pValue = float(self.uid.lineEdit_2.text())
                self.gen_is_period = float(self.uid.lineEdit_3.text())
                self.ISG.setValue(signalType, self.t_final, self.t_dt, iValue=self.gen_is_iValue, pValue=self.gen_is_pValue, period=self.gen_is_period)
            
            elif(self.isImtBtn.isChecked()): 
                signalType = 'Import'
                self.ISG.setValue(signalType, self.t_final, self.t_dt, 0, 0, 0, 0, self.expIs_time, self.expIs)
            
            try:
                self.ISG.genSignal()
                self.gen_isType = signalType
            
            except:
                self.MW.setTextEdit("[Error] Failed to generate Isoma signal.")
                self.MW.raise_()
                self.MW.activateWindow()
                # ButtonBox enable
                self.uid.applyButton.setEnabled(False)
                self.uid.okButton.setEnabled(False)
                return
            
            # x, y array
            x_array = self.ISG.times
            y_array = self.ISG.Is

        # Isyn
        elif(currentWidget == self.uid.syn_tab):  
            for i in range(len(self.groupBox_syn)):
                if(self.groupBox_syn[i].isEnabled() == True):
                    if(i==0):
                        synType = 'Excitatory'
                        signal = 'G_esyn_soma'
                    elif(i==1):
                        synType = 'Inhibitory'
                        signal = 'G_isyn_soma'
                    elif(i==2):
                        synType = 'Excitatory'
                        signal = 'G_esyn_dend'
                    elif(i==3):
                        synType = 'Inhibitory'
                        signal = 'G_isyn_dend'
                    
                    if(self.syn_FixBtn[i].isChecked()):
                        signalType = 'Step'
                        for k in range(len(self.gen_synF_heav[0])):
                            item = self.syn_tableWidget_F[i].item(k, 1)
                            self.gen_synF_heav[i][k] = float(item.text())
                        heav = self.gen_synF_heav[i]
                        iValue = 0.
                        pValue = 0.
                        period = 0.
                        exp_time = 0.
                        exp_G = 0.
                        
                        # noise O
                        if(self.syn_noise[i].isChecked()):
                            noise = True
                            item = self.syn_tableWidget_F[i].item(k+1, 1)
                            self.gen_synF_tau[i] = float(item.text())
                            item = self.syn_tableWidget_F[i].item(k+2, 1)
                            self.gen_synF_std_max[i] = float(item.text())
                            tau=self.gen_synF_tau[i]
                            std_max=self.gen_synF_std_max[i]
                        
                        # noise X
                        else:
                            noise = False
                            tau=0.
                            std_max=0.                
                    
                    elif(self.syn_TriBtn[i].isChecked()): 
                        signalType = 'Ramp'   
                        item = self.syn_tableWidget_T[i].item(0, 1)
                        self.gen_synT_iValue[i] = float(item.text())
                        item = self.syn_tableWidget_T[i].item(1, 1)
                        self.gen_synT_pValue[i] = float(item.text())
                        item = self.syn_tableWidget_T[i].item(2, 1)
                        self.gen_synT_period[i] = float(item.text())
                        heav = []
                        iValue = self.gen_synT_iValue[i]
                        pValue = self.gen_synT_pValue[i]
                        period = self.gen_synT_period[i]
                        exp_time = 0.
                        exp_G = 0.
                        
                        if(self.syn_noise[i].isChecked()):
                            noise = True
                            item = self.syn_tableWidget_T[i].item(3, 1)
                            self.gen_synT_tau[i] = float(item.text())
                            item = self.syn_tableWidget_T[i].item(4, 1)
                            self.gen_synT_std_max[i] = float(item.text())
                            tau=self.gen_synT_tau[i]
                            std_max=self.gen_synT_std_max[i]
                        
                        else:
                            noise = False
                            tau=0.
                            std_max=0.
                    
                    elif(self.syn_ImtBtn[i].isChecked()):
                        signalType = 'Import'
                        heav = []
                        iValue = 0.
                        pValue = 0.
                        period = 0.
                        noise = False
                        tau=0.
                        std_max=0.
                        exp_time = self.exp_syn_time[i]
                        exp_G = self.exp_syn[i]
                    
                    try:
                        if(i < 2):
                            self.s_SCSG.setValue(synType, signalType, self.t_final, self.t_dt, heav, iValue, pValue, period, tau, std_max, noise, exp_time, exp_G)
                            self.s_SCSG.genSignal()
                        
                        else:
                            self.d_SCSG.setValue(synType, signalType, self.t_final, self.t_dt, heav, iValue, pValue, period, tau, std_max, noise, exp_time, exp_G)
                            self.d_SCSG.genSignal()
                        self.gen_synType[i] = signalType
                    
                    except:
                        self.MW.setTextEdit("[Error] Failed to generate " + signal + " signal.")
                        self.MW.raise_()
                        self.MW.activateWindow()
                        # ButtonBox enable
                        self.uid.applyButton.setEnabled(False)
                        self.uid.okButton.setEnabled(False)
                        return
                
                # no synapse channel
                else:
                    pass
                
            # x, y array
            Se_x_array = self.s_SCSG.e_times
            Si_x_array = self.s_SCSG.i_times
            Se_y_array = self.s_SCSG.G_e
            Si_y_array = self.s_SCSG.G_i
            De_x_array = self.d_SCSG.e_times
            Di_x_array = self.d_SCSG.i_times
            De_y_array = self.d_SCSG.G_e
            Di_y_array = self.d_SCSG.G_i
        
        # Iaxon
        elif(currentWidget == self.uid.sp_tab):            
            if(self.spUserBtn.isChecked()):
                signalType = 'User'
                self.gen_spike_t1 = float(self.uid.lineEdit_4.text())                       
                self.gen_spike_t2 = float(self.uid.lineEdit_5.text())
                self.gen_spike_hz = float(self.uid.lineEdit_6.text())
                self.gen_spike_scale = float(self.uid.lineEdit_7.text())
                self.SSG.setValue(signalType, self.t_final, self.t_dt, self.gen_spike_t1, self.gen_spike_t2, self.gen_spike_hz, self.gen_spike_scale)
            
            elif(self.spExpBtn.isChecked()):
                signalType = 'Exp'
                self.SSG.setValue(signalType, self.t_final, self.t_dt, 0,0,0,0, self.ExpSpike)
            
            try:
                self.SSG.genSignal()
                self.gen_spikeType = signalType
                self.gen_spike = True
            
            except:
                self.MW.setTextEdit("[Error] Failed to generate Iaxon signal.")
                self.MW.raise_()
                self.MW.activateWindow()
                # ButtonBox enable
                self.uid.applyButton.setEnabled(False)
                self.uid.okButton.setEnabled(False)
                return
            
            # x, y array
            x_array = times
            y_array = self.SSG.spike
                
        # Xm
        elif(currentWidget == self.uid.xm_tab):  
            if(self.xmIsomeBtn.isChecked()):
                signalType = 'Isometric'
                self.gen_xm_value = float(self.uid.lineEdit_8.text())
                self.XSG.setValue(signalType, self.t_final, self.t_dt, self.gen_xm_value)
            
            elif(self.xmIsokiBtn.isChecked()):
                signalType = 'Isokinetic'
                self.gen_xm_value1 = float(self.uid.lineEdit_9.text())                       
                self.gen_xm_value2 = float(self.uid.lineEdit_10.text())                      
                self.gen_xm_t1 = float(self.uid.lineEdit_11.text())                       
                self.gen_xm_t2 = float(self.uid.lineEdit_12.text())
                self.XSG.setValue(signalType, self.t_final, self.t_dt, self.gen_xm_value1, self.gen_xm_value2, self.gen_xm_t1, self.gen_xm_t2)
            
            elif(self.xmExpBtn.isChecked()):
                signalType = 'Exp'
                self.XSG.setValue(signalType, self.t_final, self.t_dt, 0,0,0,0, self.expXm_time, self.expXm)
            
            elif(self.xmDyBtn.isChecked()):
                signalType = 'Dynamic'
                self.XSG.setValue(signalType, self.t_final, self.t_dt)
            
            try:
                self.XSG.genSignal() 
                self.gen_xmType = signalType
                self.gen_xm = True
            
            except:
                self.MW.setTextEdit("[Error] Failed to generate Xm signal.")
                self.MW.raise_()
                self.MW.activateWindow()
                # ButtonBox enable
                self.uid.applyButton.setEnabled(False)
                self.uid.okButton.setEnabled(False)
                return
            
            # x, y array     
            x_array = self.XSG.times
            y_array = self.XSG.xm

        ## plotting the signal   
        plt.rc('figure', figsize=(6, 5))
        ModelType = self.MW.ModelType
        
        # Isoma
        if(currentWidget == self.uid.is_tab):
            # figure creation
            if(self.is_fig == None):
                self.is_fig, self.is_ax=plt.subplots(nrows=1, ncols=1)
                self.is_fig.canvas.set_window_title('Intracellular Stimulation')
                self.is_fig.canvas.mpl_connect('close_event', self.FigureCloseEvent)
            self.is_ax.clear() 
            self.is_ax.set_xlabel('Time (ms)') 
            self.is_ax.set_ylabel('Is (nA)')
            self.is_ax.grid()
            self.is_ax.plot(x_array, y_array, 'r') 
            self.is_fig.canvas.draw()
            self.is_fig.show()
            self.is_fig.canvas.manager.window.raise_()
            self.MW.setTextEdit("["+ModelType+"] Somatic input signal (Isoma) generated.")
    
        # Isyn  
        elif(currentWidget == self.uid.syn_tab):
            # figure creation
            if(self.syn_fig == None):
                self.syn_fig = plt.figure()
                self.syn_fig.canvas.set_window_title('Synaptic Stimulation')
                self.syn_fig.canvas.mpl_connect('close_event', self.FigureCloseEvent)
            
            else:
                self.syn_fig.clear()
            
            s_logic = self.uid.groupBox_sesyn.isEnabled() | self.uid.groupBox_sisyn.isEnabled()
            d_logic = self.uid.groupBox_desyn.isEnabled() | self.uid.groupBox_disyn.isEnabled()
            
            if(s_logic & d_logic): # 2 axes
                self.s_ax = self.syn_fig.add_subplot(2, 1, 1)
                self.d_ax = self.syn_fig.add_subplot(2, 1, 2)
            
            elif(s_logic ^ d_logic):# 1 axis
                if(s_logic == True):
                    self.s_ax = self.syn_fig.add_subplot(1, 1, 1)
                
                else:
                    self.d_ax = self.syn_fig.add_subplot(1, 1, 1)
            
            elif(s_logic & d_logic == False):
                self.MW.setTextEdit("["+ModelType+"] No synaptic input included.")
                # no data display
                self.syn_fig.canvas.draw()
                self.syn_fig.show()
                self.MW.raise_()
                self.MW.activateWindow()
                return
            
            if(self.uid.groupBox_sesyn.isEnabled() == True):
                self.s_ax.plot(Se_x_array, Se_y_array, 'r', label='G_esyn_soma')
            if(self.uid.groupBox_sisyn.isEnabled() == True):
                self.s_ax.plot(Si_x_array, Si_y_array, 'b', label='G_isyn_soma')
            if(self.uid.groupBox_desyn.isEnabled() == True):
                self.d_ax.plot(De_x_array, De_y_array, 'r', label='G_esyn_dend')
            if(self.uid.groupBox_disyn.isEnabled() == True):
                self.d_ax.plot(Di_x_array, Di_y_array, 'b', label='G_isyn_dend')
            
            if(s_logic == True):
                self.s_ax.set_xlabel('Time (ms)')
                self.s_ax.set_ylabel('G (mS/cm^2)')
                self.s_ax.grid()
                self.s_ax.legend(loc='best')
            
            if(d_logic == True):
                self.d_ax.set_xlabel('Time (ms)') 
                self.d_ax.set_ylabel('G (mS/cm^2)')
                self.d_ax.grid()
                self.d_ax.legend(loc='best')
            self.syn_fig.canvas.draw()
            self.syn_fig.show()
            self.syn_fig.canvas.manager.window.raise_()
            self.MW.setTextEdit("["+ModelType+"] Synaptic input signal (Isyn) generated.")
        
        # Iaxon
        elif(currentWidget == self.uid.sp_tab):
            ### figure creation
            if(self.sp_fig == None):
                self.sp_fig, self.sp_ax=plt.subplots(nrows=1, ncols=1)
                self.sp_fig.canvas.set_window_title('Axonal Stimulation')  
                self.sp_fig.canvas.mpl_connect('close_event', self.FigureCloseEvent)
            self.sp_ax.clear() 
            self.sp_ax.set_xlabel('Time (ms)') 
            self.sp_ax.set_ylabel('Iaxon')
            self.sp_ax.grid()
            self.sp_ax.plot(x_array, y_array, 'r') 
            self.sp_fig.canvas.draw()
            self.sp_fig.show()
            self.sp_fig.canvas.manager.window.raise_()
            self.MW.setTextEdit("["+ModelType+"] Axonal input signal (Iaxon) generated.")
               
        # Xm
        elif(currentWidget == self.uid.xm_tab):
            ### figure creation
            if(self.xm_fig == None):
                self.xm_fig, self.xm_ax=plt.subplots(nrows=1, ncols=1)
                self.xm_fig.canvas.set_window_title('Muscle Length')
                self.xm_fig.canvas.mpl_connect('close_event', self.FigureCloseEvent)
            self.xm_ax.clear() 
            self.xm_ax.set_xlabel('Time (ms)') 
            self.xm_ax.set_ylabel('Xm (mm)')
            self.xm_ax.grid()
            self.xm_ax.plot(x_array, y_array, 'r') 
            self.xm_fig.canvas.draw()
            self.xm_fig.show()
            self.xm_fig.canvas.manager.window.raise_()
            self.MW.setTextEdit("["+ModelType+"] Muscle length signal (Xm) generated.")
        
        # ButtonBox enable
        self.uid.applyButton.setEnabled(True)
        self.uid.okButton.setEnabled(True)
        
    def FigureCloseEvent(self, event):
        figure = event.canvas.figure
        
        if(figure == self.is_fig):
            self.is_fig = None
        elif(figure == self.syn_fig):
            self.syn_fig = None
        elif(figure == self.sp_fig):
            self.sp_fig = None
        elif(figure == self.xm_fig):
            self.xm_fig = None
        
# Output Signals Window class         
class OscilloscopeWindow(QDialog):
    def __init__(self, MW):
        super(OscilloscopeWindow, self).__init__()
        self.MW = MW
        
        # subscript, superscript, Greek letter with unicode and unit label
        super_2 = u'\u00B2'
        super_2_p = super_2 + u'\u207A'
        mV = ' (mV)'
        mM = ' (mM)'
        cm_2 = 'cm'+super_2
        mA_cm_2 = ' (mA/' + cm_2 + ')'
        mS_cm_2 = ' (mS/' + cm_2 + ')'
        M = ' (M)'
        sub_i = u'\u1D62'
        tilde = u'\u0303'
        
        # subscript with HTML
        sub_Naf = '<sub>Naf</sub>' 
        sub_Nap = '<sub>Nap</sub>'
        sub_Kdr = '<sub>Kdr</sub>' 
        sub_KCa = '<sub>K(Ca)</sub>' 
        sub_Can = '<sub>Can</sub>' 
        sub_H = '<sub>H</sub>' 
        sub_esyn = '<sub>esyn</sub>' 
        sub_isyn = '<sub>isyn</sub>'
        sub_Cal = '<sub>Cal</sub>'
        sub_Ca = '<sub>Ca</sub>' 
        sub_SR = '<sub>SR</sub>'
        sub_SP = '<sub>SP</sub>' 
        sub_CE = '<sub>CE</sub>'
        
        ## initialization
        # set value
        self.mn_itemList = ['Is', 'V_soma', 'Firing_rate', '[Ca]_soma', 'E_Ca_soma', 'I_Naf_soma', 'm_Naf_soma', 'h_Naf_soma', 'I_Nap_soma', 'm_Nap_soma', 'I_Kdr_soma', 'n_Kdr_soma', 'I_Kca_soma', 'I_Can_soma', 'm_Can_soma', 'h_Can_soma', 'I_H_soma', 'm_H_soma', 'I_esyn_soma', 'G_esyn_soma', 'I_isyn_soma', 'G_isyn_soma', 'V_dend', '[Ca]_dend', 'E_Ca_dend', 'I_Cal_dend', 'l_Cal_dend', 'I_Naf_dend', 'm_Naf_dend', 'h_Naf_dend', 'I_Nap_dend', 'm_Nap_dend', 'I_Kdr_dend', 'n_Kdr_dend', 'I_Kca_dend', 'I_Can_dend', 'm_Can_dend', 'h_Can_dend', 'I_H_dend', 'm_H_dend', 'I_esyn_dend', 'G_esyn_dend', 'I_isyn_dend', 'G_isyn_dend']
        self.mf_itemList = ['F', 'Spike', 'R', 'Xm', 'Vm', 'Am', 'Cs', 'CaSR', 'CaSRCS', 'B', 'CaSP', 'T' ,'CaSPB', 'CaSPT', 'A_tilde', 'XCE', 'A']
        self.mn_list_num = len(self.mn_itemList)
        self.mf_list_num = len(self.mf_itemList)
        self.mn_ScopeList = set()
        self.mf_ScopeList = set()
        
        # check box state
        self.mn_checkbox_state = []
        self.mf_checkbox_state = []
        for i in range(self.mn_list_num):
            self.mn_checkbox_state.append(False) # unchecked
        for i in range(self.mf_list_num):
            self.mf_checkbox_state.append(False)
        
        ## GUI
        self.uid = Ui_OD()
        self.uid.setupUi(self)
        
        # groupbox Label
        self.uid.checkBox_Sv.setText('V' + mV)
        self.uid.groupBox_Sca.setTitle('d[Ca' + super_2_p + ']' + sub_i + '/dt  ')
        self.uid.checkBox_Sca.setText('[Ca' + super_2_p + ']' + sub_i + mM)
        self.uid.label_Svca.setText('E' + sub_Ca + mV)
        self.uid.checkBox_SnaI.setText('I' + mA_cm_2)
        self.uid.label_Snaf.setText('I' + sub_Naf)
        self.uid.checkBox_SnapI.setText('I' + mA_cm_2)
        self.uid.label_Snap.setText('I' + sub_Nap)
        self.uid.checkBox_SkdrI.setText('I' + mA_cm_2)
        self.uid.label_Skdr.setText('I' + sub_Kdr)
        self.uid.checkBox_SkcaI.setText('I' + mA_cm_2)
        self.uid.label_Skca.setText('I' + sub_KCa)
        self.uid.checkBox_ScaI.setText('I' + mA_cm_2)
        self.uid.label_Scan.setText('I' + sub_Can)
        self.uid.checkBox_ShI.setText('I' + mA_cm_2)
        self.uid.label_Sh.setText('I' + sub_H)
        self.uid.checkBox_SesynI.setText('I ' + mA_cm_2)
        self.uid.label_Sesyn.setText('I' + sub_esyn)
        self.uid.checkBox_SisynI.setText('I ' + mA_cm_2)
        self.uid.label_Sisyn.setText('I' + sub_isyn)
        self.uid.checkBox_Sgesyn.setText('G' + mS_cm_2)
        self.uid.checkBox_Sgisyn.setText('G' + mS_cm_2)
        self.uid.checkBox_Dv.setText('V' + mV)
        self.uid.groupBox_Dca.setTitle('d[Ca' + super_2_p + ']' + sub_i + '/dt  ')
        self.uid.checkBox_Dca.setText('[Ca' + super_2_p + ']' + sub_i + mM)
        self.uid.label_Dvca.setText('E' + sub_Ca + mV)
        self.uid.checkBox_DcalI.setText('I' + mA_cm_2)
        self.uid.label_Dcal.setText('I' + sub_Cal)
        self.uid.checkBox_DnaI.setText('I' + mA_cm_2)
        self.uid.label_Dnaf.setText('I' + sub_Naf)
        self.uid.checkBox_DnapI.setText('I' + mA_cm_2)
        self.uid.label_Dnap.setText('I' + sub_Nap)
        self.uid.checkBox_DkdrI.setText('I' + mA_cm_2)
        self.uid.label_Dkdr.setText('I' + sub_Kdr)
        self.uid.checkBox_DkcaI.setText('I' + mA_cm_2)
        self.uid.label_Dkca.setText('I' + sub_KCa)
        self.uid.checkBox_DcaI.setText('I' + mA_cm_2)
        self.uid.label_Dcan.setText('I' + sub_Can)
        self.uid.checkBox_DhI.setText('I' + mA_cm_2)
        self.uid.label_Dh.setText('I' + sub_H)
        self.uid.checkBox_DesynI.setText('I ' + mA_cm_2)
        self.uid.label_Desyn.setText('I' + sub_esyn)
        self.uid.checkBox_DisynI.setText('I ' + mA_cm_2)
        self.uid.label_Disyn.setText('I' + sub_isyn)
        self.uid.checkBox_Dgesyn.setText('G' + mS_cm_2)
        self.uid.checkBox_Dgisyn.setText('G' + mS_cm_2)
        self.uid.checkBox_CS.setText('[CS]' + M)
        self.uid.label_CaSR.setText('[Ca' + sub_SR + ']' + M)
        self.uid.label_CaSRCS.setText('[Ca' + sub_SR + 'CS]' + M)
        self.uid.checkBox_B.setText('[B]' + M)
        self.uid.label_CaSP.setText('[Ca' + sub_SP + ']' + M)
        self.uid.checkBox_T.setText('[T]' + M)
        self.uid.label_CaSPB.setText('[Ca' + sub_SP + 'B]' + M)
        self.uid.label_CaSPT.setText('[Ca' + sub_SP + 'T]' + M)
        self.uid.checkBox_Xm.setText('Xm (mm)')
        self.uid.checkBox_Vm.setText('Vm (mm/s)')
        self.uid.checkBox_Am.setText('Am (mm/s' + super_2 + ')')
        self.uid.checkBox_F.setText('F (N)')
        self.uid.label_A.setText('A' + tilde)
        self.uid.label_XCE.setText('X' + sub_CE + ' (mm)')
        
        # set radio button
        self.displayResult = self.uid.radioButton_Individual
        self.displayResult.setChecked(True)
        
        # checkbox_list
        self.mn_checkbox_list = []
        self.mn_checkbox_list.append(self.uid.checkBox_SIs)
        self.mn_checkbox_list.append(self.uid.checkBox_Sv)
        self.mn_checkbox_list.append(self.uid.checkBox_SR)
        self.mn_checkbox_list.append(self.uid.checkBox_Sca)
        self.mn_checkbox_list.append(self.uid.checkBox_Svca)
        self.mn_checkbox_list.append(self.uid.checkBox_SnaI)
        self.mn_checkbox_list.append(self.uid.checkBox_Snam)
        self.mn_checkbox_list.append(self.uid.checkBox_Snah)
        self.mn_checkbox_list.append(self.uid.checkBox_SnapI)
        self.mn_checkbox_list.append(self.uid.checkBox_Snapm)
        self.mn_checkbox_list.append(self.uid.checkBox_SkdrI)
        self.mn_checkbox_list.append(self.uid.checkBox_Skdr)
        self.mn_checkbox_list.append(self.uid.checkBox_SkcaI)
        self.mn_checkbox_list.append(self.uid.checkBox_ScaI)
        self.mn_checkbox_list.append(self.uid.checkBox_Scam)
        self.mn_checkbox_list.append(self.uid.checkBox_Scah)
        self.mn_checkbox_list.append(self.uid.checkBox_ShI)
        self.mn_checkbox_list.append(self.uid.checkBox_Shm)
        self.mn_checkbox_list.append(self.uid.checkBox_SesynI)
        self.mn_checkbox_list.append(self.uid.checkBox_Sgesyn)
        self.mn_checkbox_list.append(self.uid.checkBox_SisynI)
        self.mn_checkbox_list.append(self.uid.checkBox_Sgisyn)
        self.mn_checkbox_list.append(self.uid.checkBox_Dv)
        self.mn_checkbox_list.append(self.uid.checkBox_Dca)
        self.mn_checkbox_list.append(self.uid.checkBox_Dvca)
        self.mn_checkbox_list.append(self.uid.checkBox_DcalI)
        self.mn_checkbox_list.append(self.uid.checkBox_Dcal)
        self.mn_checkbox_list.append(self.uid.checkBox_DnaI)
        self.mn_checkbox_list.append(self.uid.checkBox_Dnam)
        self.mn_checkbox_list.append(self.uid.checkBox_Dnah)
        self.mn_checkbox_list.append(self.uid.checkBox_DnapI)
        self.mn_checkbox_list.append(self.uid.checkBox_Dnapm)
        self.mn_checkbox_list.append(self.uid.checkBox_DkdrI)
        self.mn_checkbox_list.append(self.uid.checkBox_Dkdr)
        self.mn_checkbox_list.append(self.uid.checkBox_DkcaI)
        self.mn_checkbox_list.append(self.uid.checkBox_DcaI)
        self.mn_checkbox_list.append(self.uid.checkBox_Dcam)
        self.mn_checkbox_list.append(self.uid.checkBox_Dcah)
        self.mn_checkbox_list.append(self.uid.checkBox_DhI)
        self.mn_checkbox_list.append(self.uid.checkBox_Dhm)
        self.mn_checkbox_list.append(self.uid.checkBox_DesynI)
        self.mn_checkbox_list.append(self.uid.checkBox_Dgesyn)
        self.mn_checkbox_list.append(self.uid.checkBox_DisynI)
        self.mn_checkbox_list.append(self.uid.checkBox_Dgisyn)
        self.mf_checkbox_list = []
        self.mf_checkbox_list.append(self.uid.checkBox_F)
        self.mf_checkbox_list.append(self.uid.checkBox_Spike)
        self.mf_checkbox_list.append(self.uid.checkBox_R)
        self.mf_checkbox_list.append(self.uid.checkBox_Xm)
        self.mf_checkbox_list.append(self.uid.checkBox_Vm)
        self.mf_checkbox_list.append(self.uid.checkBox_Am)
        self.mf_checkbox_list.append(self.uid.checkBox_CS)
        self.mf_checkbox_list.append(self.uid.checkBox_CaSR)
        self.mf_checkbox_list.append(self.uid.checkBox_CaSRCS)
        self.mf_checkbox_list.append(self.uid.checkBox_B)
        self.mf_checkbox_list.append(self.uid.checkBox_CaSP)
        self.mf_checkbox_list.append(self.uid.checkBox_T)
        self.mf_checkbox_list.append(self.uid.checkBox_CaSPB)
        self.mf_checkbox_list.append(self.uid.checkBox_CaSPT)
        self.mf_checkbox_list.append(self.uid.checkBox_A)
        self.mf_checkbox_list.append(self.uid.checkBox_XCE)
        self.mf_checkbox_list.append(self.uid.checkBox_As)
        
        # GUI operation-function 
        self.uid.buttonBox.connect(self.uid.buttonBox, SIGNAL("accepted()"), self.setScopeList)
        self.uid.buttonBox.connect(self.uid.applyButton, SIGNAL("clicked()"), self.setScopeList)

    def keyPressEvent(self, event):
        # operation of Key_Return or Key_Enter
        if(event.key() == 0x01000005 or event.key() == 0x01000004):
            pass
        else:
            # QDialog event
            super(OscilloscopeWindow, self).keyPressEvent(event) 
            
    def setObjectEnabled(self, from_self=True):
        # object enable setting
        if(self.MW.PSW.channel_enable['Snaf'] == True):
            self.uid.groupBox_Snaf.setEnabled(True)
        else:
            self.uid.groupBox_Snaf.setEnabled(False)
            self.uid.checkBox_SnaI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Snam.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Snah.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Snap'] == True):
            self.uid.groupBox_Snap.setEnabled(True)
        else:
            self.uid.groupBox_Snap.setEnabled(False)
            self.uid.checkBox_SnapI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Snapm.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Skdr'] == True):
            self.uid.groupBox_Skdr.setEnabled(True)
        else:
            self.uid.groupBox_Skdr.setEnabled(False)
            self.uid.checkBox_SkdrI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Skdr.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Skca'] == True):
            self.uid.groupBox_Skca.setEnabled(True)
        else:
            self.uid.groupBox_Skca.setEnabled(False)
            self.uid.checkBox_SkcaI.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Scan'] == True):
            self.uid.groupBox_Scan.setEnabled(True)
        else:
            self.uid.groupBox_Scan.setEnabled(False)
            self.uid.checkBox_ScaI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Scam.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Scah.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Sh'] == True):
            self.uid.groupBox_Sh.setEnabled(True)
        else:
            self.uid.groupBox_Sh.setEnabled(False)
            self.uid.checkBox_ShI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Shm.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Sesyn'] == True):
            self.uid.groupBox_Sesyn.setEnabled(True)
        else:
            self.uid.groupBox_Sesyn.setEnabled(False)
            self.uid.checkBox_SesynI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Sgesyn.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Sisyn'] == True):
            self.uid.groupBox_Sisyn.setEnabled(True)
        else:
            self.uid.groupBox_Sisyn.setEnabled(False)
            self.uid.checkBox_SisynI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Sgisyn.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Dcal'] == True):
            self.uid.groupBox_Dcal.setEnabled(True)
        else:
            self.uid.groupBox_Dcal.setEnabled(False)
            self.uid.checkBox_DcalI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dcal.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Dnaf'] == True):
            self.uid.groupBox_Dnaf.setEnabled(True)
        else:
            self.uid.groupBox_Dnaf.setEnabled(False)
            self.uid.checkBox_DnaI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dnam.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dnah.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Dnap'] == True):
            self.uid.groupBox_Dnap.setEnabled(True)
        else:
            self.uid.groupBox_Dnap.setEnabled(False)
            self.uid.checkBox_DnapI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dnapm.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Dkdr'] == True):
            self.uid.groupBox_Dkdr.setEnabled(True)
        else:
            self.uid.groupBox_Dkdr.setEnabled(False)
            self.uid.checkBox_DkdrI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dkdr.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Dkca'] == True):
            self.uid.groupBox_Dkca.setEnabled(True)
        else:
            self.uid.groupBox_Dkca.setEnabled(False)
            self.uid.checkBox_DkcaI.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Dcan'] == True):
            self.uid.groupBox_Dcan.setEnabled(True)
        else:
            self.uid.groupBox_Dcan.setEnabled(False)
            self.uid.checkBox_DcaI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dcam.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dcah.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Dh'] == True):
            self.uid.groupBox_Dh.setEnabled(True)
        else:
            self.uid.groupBox_Dh.setEnabled(False)
            self.uid.checkBox_DhI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dhm.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Desyn'] == True):
            self.uid.groupBox_Desyn.setEnabled(True)
        else:
            self.uid.groupBox_Desyn.setEnabled(False)
            self.uid.checkBox_DesynI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dgesyn.setCheckState(Qt.Unchecked)
            
        if(self.MW.PSW.channel_enable['Disyn'] == True):
            self.uid.groupBox_Disyn.setEnabled(True)
        else:
            self.uid.groupBox_Disyn.setEnabled(False)
            self.uid.checkBox_DisynI.setCheckState(Qt.Unchecked)
            self.uid.checkBox_Dgisyn.setCheckState(Qt.Unchecked)
        
            self.setScopeList(from_self)
            
    def displayScope(self):
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):        
            self.setObjectEnabled()        
            # checkbox check or uncheck           
            for i in range(self.mn_list_num):
                if(self.mn_checkbox_state[i] == False):
                    self.mn_checkbox_list[i].setCheckState(Qt.Unchecked)
                else: 
                    self.mn_checkbox_list[i].setCheckState(Qt.Checked)
        
        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'):
            for i in range(self.mf_list_num):
                if(self.mf_checkbox_state[i] == False):
                    self.mf_checkbox_list[i].setCheckState(Qt.Unchecked)
                else:
                    self.mf_checkbox_list[i].setCheckState(Qt.Checked)
        
        # tab enable
        if(self.MW.ModelType == 'Motoneuron'):            
            self.uid.tabWidget.setTabEnabled(0, True)
            self.uid.tabWidget.setTabEnabled(1, False)
        elif(self.MW.ModelType == 'Muscle Fibers'):            
            self.uid.tabWidget.setTabEnabled(0, False)
            self.uid.tabWidget.setTabEnabled(1, True)       
        elif(self.MW.ModelType == 'Motor Unit'):            
            self.uid.tabWidget.setTabEnabled(0, True)
            self.uid.tabWidget.setTabEnabled(1, True)
            self.uid.tabWidget.setCurrentIndex(0)
        
        self.displayResult.setChecked(True)

    def setScopeList(self, from_self=True):
        # set the scope
        if(self.MW.ModelType == 'Motoneuron' or self.MW.ModelType == 'Motor Unit'):            
            for i in range(self.mn_list_num):                
                if(self.mn_checkbox_list[i].isChecked()):
                    self.mn_checkbox_state[i] = True
                    self.mn_ScopeList.add(self.mn_itemList[i])
                
                elif(not(self.mn_checkbox_list[i].isChecked()) and self.mn_checkbox_state[i] == True):
                    self.mn_checkbox_state[i] = False
                    self.mn_ScopeList.remove(self.mn_itemList[i])

        if(self.MW.ModelType == 'Muscle Fibers' or self.MW.ModelType == 'Motor Unit'):            
            for i in range(self.mf_list_num):                
                if(self.mf_checkbox_list[i].isChecked()):
                    self.mf_checkbox_state[i] = True
                    self.mf_ScopeList.add(self.mf_itemList[i])
                
                elif(not(self.mf_checkbox_list[i].isChecked()) and self.mf_checkbox_state[i] == True):
                    self.mf_checkbox_state[i] = False
                    self.mf_ScopeList.remove(self.mf_itemList[i])
       
        if(from_self==True):
            # Text message
            if(self.MW.ModelType == 'Motoneuron'):
                self.MW.setTextEdit("[Motoneuron] Output variables for plotting set.")
                item = "Item : "
                mn_num = len(self.mn_ScopeList)
                j = 1
                
                for i in self.mn_ScopeList:
                    if(j == mn_num):
                        item = item + str(i)
                    else:
                        item = item + str(i) + ", "
                    j += 1
                
                self.MW.uim.textEdit.append(item)
            
            elif(self.MW.ModelType == 'Muscle Fibers'):
                self.MW.setTextEdit("[Muscle Fibers] Output variables for plotting set.")
                item = "Item : "
                mf_num = len(self.mf_ScopeList)
                j = 1
                
                for i in self.mf_ScopeList:
                    if(j == mf_num):
                        item = item + str(i)
                    else:
                        item = item + str(i) + ", "
                    j += 1
                
                self.MW.uim.textEdit.append(item)
            
            elif(self.MW.ModelType == 'Motor Unit'):
                self.MW.setTextEdit("[Motor Unit] Output variables for plotting set.")
                item = "Item : [MN] "
                mn_num = len(self.mn_ScopeList)
                j = 1
                
                for i in self.mn_ScopeList:
                    if(j == mn_num):
                        item = item + str(i)
                    else:
                        item = item + str(i) + ", "
                    j += 1
                
                self.MW.uim.textEdit.append(item)
    
                item = "Item : [MF] "
                mf_num = len(self.mf_ScopeList)
                j = 1
                
                for i in self.mf_ScopeList:
                    if(j == mf_num):
                        item = item + str(i)
                    else:
                        item = item + str(i) + ", "
                    j += 1
                
                self.MW.uim.textEdit.append(item)
            
            # radio button set
            if(self.uid.radioButton_Individual.isChecked()):
                self.displayResult = self.uid.radioButton_Individual
                self.MW.uim.textEdit.append("Display : Separate") 
            elif(self.uid.radioButton_Combined.isChecked()):
                self.displayResult = self.uid.radioButton_Combined
                self.MW.uim.textEdit.append("Display : Overlapped")


if __name__  ==  '__main__':
    
    app=QApplication(sys.argv)

    # Main window instance
    MW = MainWindow()
    MW.show()
    app.exec_()
    
    del MW
    

Loading data, please wait...