HYTOS

# coding: utf-8

import os

import sys

import sqlite3

from SingletonInstance import SingletonInstane

'''

    @brief      HMB data

'''

class HMBData:

    def __init__(self, uid=None):

        self._uid = None

        self._components_uid = None

        self._stream_no = None

        self._phase_type = None

        self._flowrate_mass = None

        self._flowrate_volume = None

        self._density = None

        self._viscosity = None

        self._temperature = None

        self._molecular_weight = None

        self._specific_heat_ratio = None

        self._compress_factor = None

        self._nominal_pipe_size = None

        self._inside_pipe_size = None

        self._schedule_no = None

        self._straight_length = None

        self._equivalent_length_input = None

        self._fitting_length = None

        self._fitting_K = None

        self._equivalent_length_cal = None

        self._roughness = None

        self._limitation_velocity = None

        self._limitation_pressure_drop = None

        self._velocity = None

        self._reynolds = None

        self._friction_factor = None

        self._pressure_drop = None

        self._pressure_drop_friction = None

        self._pressure_drop_static = None

        self._pressure_pipe_end_point = None

        self._power = None

        self.isDeleted = False

    '''

        @author humkyung

        @date   2018.07.12

    '''

    @property

    def uid(self):

        return self._uid

    '''

        @author humkyung

        @date   2018.07.12

    '''

    @uid.setter

    def uid(self, value):

        self._uid = value

    '''

        @author humkyung

        @date   2018.07.12

    '''

    @property

    def components_uid(self):

        return self._components_uid

    '''

        @author humkyung

        @date   2018.07.12

    '''

    @components_uid.setter

    def components_uid(self, value):

        self._components_uid = value

    '''

        @author humkyung

        @date   2018.07.12

    '''

    @property

    def stream_no(self):

        return self._stream_no

    '''

        @author humkyung

        @date   2018.07.12

    '''

    @stream_no.setter

    def stream_no(self, value):

        if value:

            self._stream_no = int(value)

    @property

    def phase_type(self):

        return self._phase_type

    @phase_type.setter

    def phase_type(self, value):

        if value:

            self._phase_type = value

    @property

    def flowrate_mass(self):

        return self._flowrate_mass

    @flowrate_mass.setter

    def flowrate_mass(self, value):

        self._flowrate_mass = float(value) if value else None

    @property

    def flowrate_volume(self):

        return self._flowrate_volume

    @flowrate_volume.setter

    def flowrate_volume(self, value):

        self._flowrate_volume = float(value) if value else None

    @property

    def density(self):

        return self._density

    @density.setter

    def density(self, value):

        self._density = float(value) if value else None

    @property

    def viscosity(self):

        return self._viscosity

    @viscosity.setter

    def viscosity(self, value):

        self._viscosity = float(value) if value else None

    @property

    def temperature(self):

        return self._temperature

    @temperature.setter

    def temperature(self, value):

        self._temperature = float(value) if value else None

    @property

    def molecular_weight(self):

        return self._molecular_weight

    @molecular_weight.setter

    def molecular_weight(self, value):

        self._molecular_weight = float(value) if value else None

    @property

    def specific_heat_ratio(self):

        return self._specific_heat_ratio

    @specific_heat_ratio.setter

    def specific_heat_ratio(self, value):

        self._specific_heat_ratio = float(value) if value else None

    @property

    def compress_factor(self):

        return self._compress_factor

    @compress_factor.setter

    def compress_factor(self, value):

        self._compress_factor = float(value) if value else None

    @property

    def nominal_pipe_size(self):

        return self._nominal_pipe_size

    @nominal_pipe_size.setter

    def nominal_pipe_size(self, value):

        self._nominal_pipe_size = float(value) if value else None

    @property

    def inside_pipe_size(self):

        return self._inside_pipe_size

    @inside_pipe_size.setter

    def inside_pipe_size(self, value):

        self._inside_pipe_size = float(value) if value else None

    @property

    def schedule_no(self):

        return self._schedule_no

    @schedule_no.setter

    def schedule_no(self, value):

        if value:

            self._schedule_no = value

    @property

    def straight_length(self):

        return self._straight_length

    @straight_length.setter

    def straight_length(self, value):

        self._straight_length = float(value) if value else None

    @property

    def equivalent_length_input(self):

        return self._equivalent_length_input

    @equivalent_length_input.setter

    def equivalent_length_input(self, value):

        self._equivalent_length_input = float(value) if value else None

    @property

    def fitting_length(self):

        return self._fitting_length

    @fitting_length.setter

    def fitting_length(self, value):

        self._fitting_length = float(value) if value else None

    @property

    def fitting_K(self):

        return self._fitting_K

    @fitting_K.setter

    def fitting_K(self, value):

        self._fitting_K = float(value) if value else None

    @property

    def equivalent_length_cal(self):

        return self._equivalent_length_cal

    @equivalent_length_cal.setter

    def equivalent_length_cal(self, value):

        self._equivalent_length_cal = float(value) if value else None

    @property

    def roughness(self):

        return self._roughness

    @roughness.setter

    def roughness(self, value):

        self._roughness = float(value) if value else None

    @property

    def limitation_velocity(self):

        return self._limitation_velocity

    @limitation_velocity.setter

    def limitation_velocity(self, value):

        self._limitation_velocity = float(value) if value else None

    @property

    def limitation_pressure_drop(self):

        return self._limitation_pressure_drop

    @limitation_pressure_drop.setter

    def limitation_pressure_drop(self, value):

        self._limitation_pressure_drop = float(value) if value else None

    @property

    def velocity(self):

        return self._velocity

    @velocity.setter

    def velocity(self, value):

        self._velocity = float(value) if value else None

    @property

    def reynolds(self):

        return self._reynolds

    @reynolds.setter

    def reynolds(self, value):

        self._reynolds = float(value) if value else None

    @property

    def friction_factor(self):

        return self._friction_factor

    @friction_factor.setter

    def friction_factor(self, value):

        self._friction_factor = float(value) if value else None

    @property

    def pressure_drop(self):

        return self._pressure_drop

    @pressure_drop.setter

    def pressure_drop(self, value):

        self._pressure_drop = float(value) if value else None

    @property

    def pressure_drop_friction(self):

        return self._pressure_drop_friction

    @pressure_drop_friction.setter

    def pressure_drop_friction(self, value):

        self._pressure_drop_friction = float(value) if value else None

    @property

    def pressure_drop_static(self):

        return self._pressure_drop_static

    @pressure_drop_static.setter

    def pressure_drop_static(self, value):

        self._pressure_drop_static = float(value) if value is not None else None

    @property

    def pressure_pipe_end_point(self):

        return self._pressure_pipe_end_point

    @pressure_pipe_end_point.setter

    def pressure_pipe_end_point(self, value):

        self._pressure_pipe_end_point = float(value) if value is not None else None

    @property

    def power(self):

        return self._power

    @power.setter

    def power(self, value):

        self._power = float(value) if value is not None else None

    def fromRow(row):

        hmb = HMBData()

        hmb._uid = row[0]

        hmb._components_uid = row[1]

        hmb._stream_no = row[2]

        hmb._phase_type = row[3]

        hmb._flowrate_mass = row[4]

        hmb._flowrate_volume = row[5]

        hmb._density = row[6]

        hmb._viscosity = row[7]

        hmb._temperature = row[8]

        hmb._molecular_weight = row[9]

        hmb._specific_heat_ratio = row[10]

        hmb._compress_factor = row[11]

        hmb._nominal_pipe_size = row[12]

        hmb._inside_pipe_size = row[13]

        hmb._schedule_no = row[14]

        hmb._straight_length = row[15]

        hmb._equivalent_length_input = row[16]

        hmb._fitting_length = row[17]

        hmb._fitting_K = row[18]

        hmb._equivalent_length_cal = row[19]

        hmb._roughness = row[20]

        hmb._limitation_velocity = row[21]

        hmb._limitation_pressure_drop = row[22]

        hmb._velocity = row[23]

        hmb._reynolds = row[24]

        hmb._friction_factor = row[25]

        hmb._pressure_drop = row[26]

        hmb._pressure_drop_friction = row[27]

        hmb._pressure_drop_static = row[28]

        hmb._pressure_pipe_end_point = row[29]

        hmb._power = row[30]

        return hmb

class HMBTable:

    '''

        @brief  constructor

        @author humkyung

        @date   2018.07.12

    '''

    def __init__(self):

        self._hmbs = None

    @staticmethod

    def new_data():

        # 새로운 HMB 데이타를 생성한다.

        hmb = HMBData()

        hmb.isDeleted = False

        return hmb

    '''

        @brief      delete hmb data by uid

        @author     yeonjin

        @date       2019.08.19

    '''

    def deleteByUID(self, uid):

        hmbs = self._hmbs

        if hmbs is not None:

            for hmb in hmbs:

                if str(hmb.components_uid) == str(uid):

                    hmb.isDeleted = True

                    break

    def add(self, components_uid, stream_no):

        import uuid

        hmb = HMBData()

        hmb.uid = str(uuid.uuid4())

        hmb.components_uid = components_uid

        hmb.stream_no = stream_no

        hmb.isDeleted = False

        self.append(hmb)

    def updateByUID(self, components_uid, values):

        try:

            for hmb in self._hmbs:

                if hmb.components_uid == components_uid:

                    if 'Phase_Type' in values:

                        hmb.phase_type = values['Phase_Type']

                    if 'Flowrate_Mass' in values:

                        hmb.flowrate_mass = values['Flowrate_Mass']

                    if 'Flowrate_Volume' in values:

                        hmb.flowrate_volume = values['Flowrate_Volume']

                    if 'Viscosity' in values:

                        hmb.viscosity = values['Viscosity']

                    if 'Density' in values:

                        hmb.density = values['Density']

                    if 'Temperature' in values:

                        hmb.temperature = values['Temperature']

                    if 'Molecular_Weight' in values:

                        hmb.molecular_weight = values['Molecular_Weight']

                    if 'Specific_Heat_Ratio' in values:

                        hmb.specific_heat_ratio = values['Specific_Heat_Ratio']

                    if 'Compress_Factor' in values:

                        hmb.compress_factor = values['Compress_Factor']

                    if 'Nominal_Pipe_Size' in values:

                        hmb.nominal_pipe_size = values['Nominal_Pipe_Size']

                    if 'Inside_Pipe_Size' in values:

                        hmb.inside_pipe_size = values['Inside_Pipe_Size']

                    if 'Schedule_No' in values:

                        hmb.schedule_no = values['Schedule_No']

                    if 'Straight_Length' in values:

                        hmb.straight_length = values['Straight_Length']

                    if 'Equivalent_Length_Input' in values:

                        hmb.equivalent_length_input = values['Equivalent_Length_Input']

                    if 'Fitting_Length' in values:

                        hmb.fitting_length = values['Fitting_Length']

                    if 'Fitting_K' in values:

                        hmb.fitting_K = values['Fitting_K']

                    if 'Equivalent_Length_Cal' in values:

                        hmb.equivalent_length_cal = values['Equivalent_Length_Cal']

                    if 'Roughness' in values:

                        hmb.roughness = values['Roughness']

                    if 'Limitation_Velocity' in values:

                        hmb.limitation_velocity = values['Limitation_Velocity']

                    if 'Limitation_Pressure_Drop' in values:

                        hmb.limitation_pressure_drop = values['Limitation_Pressure_Drop']

                    if 'Velocity' in values:

                        hmb.velocity = values['Velocity']

                    if 'Reynolds' in values:

                        hmb.reynolds = values['Reynolds']

                    if 'Friction_Factor' in values:

                        hmb.friction_factor = values['Friction_Factor']

                    if 'Pressure_Drop' in values:

                        hmb.pressure_drop = values['Pressure_Drop']

                    if 'Pressure_Drop_Friction' in values:

                        hmb.pressure_drop_friction = values['Pressure_Drop_Friction']

                    if 'Pressure_Drop_Static' in values:

                        hmb.pressure_drop_static = values['Pressure_Drop_Static']

                    if 'Pressure_Pipe_End_Point' in values:

                        hmb.pressure_pipe_end_point = values['Pressure_Pipe_End_Point']

                    if 'Power' in values:

                        hmb.power = values['Power']

                    break

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                           sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        @brief      load hmb data from database

        @author     humkyung

        @date       2018.07.12

    '''

    def load_data_by_drawing(self, drawing):

        from App import App

        from AppDocData import AppDocData

        if self._hmbs is None:

            self._hmbs = []

            conn = sqlite3.connect(drawing.path)

            conn.execute('PRAGMA foreign_keys = ON')

            with conn:

                try:

                    cursor = conn.cursor()

                    sql = """select h.UID

                                , h.Components_UID

                                , h.Stream_No

                                , h.Phase_Type

                                , h.Flowrate_Mass

                                , h.Flowrate_Volume

                                , h.Density

                                , h.Viscosity

                                , h.Temperature

                                , h.Molecular_Weight

                                , h.Specific_Heat_Ratio

                                , h.Compress_Factor

                                , h.Nominal_Pipe_Size

                                , h.Inside_Pipe_Size

                                , h.Schedule_No

                                , h.Straight_Length

                                , h.Equivalent_Length_Input

                                , h.Fitting_Length

                                , h.Fitting_K

                                , h.Equivalent_Length_Cal

                                , h.Roughness

                                , h.Limitation_Velocity

                                , h.Limitation_Pressure_Drop

                                , h.Velocity

                                , h.Reynolds

                                , h.Friction_Factor

                                , h.Pressure_Drop

                                , h.Pressure_Drop_Friction

                                , h.Pressure_Drop_Static

                                , h.Pressure_Pipe_End_Point

                                , h.Power

                            from HMB h

                            left join Components c

                                on h.Components_UID = c.UID

                            order by h.Stream_No"""

                    cursor.execute(sql)

                    rows = cursor.fetchall()

                    for row in rows:

                        hmb = HMBData.fromRow(row)

                        self._hmbs.append(hmb)

                # Catch the exception

                except Exception as ex:

                    from App import App

                    from AppDocData import MessageType

                    # Roll back any change if something goes wrong

                    conn.rollback()

                    message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                                  sys.exc_info()[-1].tb_lineno)

                    App.mainWnd().addMessage.emit(MessageType.Error, message)

        return self._hmbs

    '''

        @brief      save hmb data 

        @author     humkyung

        @date       2018.07.12

    '''

    def saveData(self):

        import uuid

        from App import App

        from AppDocData import AppDocData

        if self._hmbs is None:

            return

        app_doc_data = AppDocData.instance()

        conn = sqlite3.connect(app_doc_data.activeDrawing.path)

        conn.execute('PRAGMA foreign_keys = ON')

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                for data in self._hmbs:

                    if data.isDeleted == False:

                        cols = ['UID', 'Components_UID', 'Stream_No', 'Phase_Type', 'Flowrate_Mass', 'Flowrate_Volume',

                                'Density', 'Viscosity',

                                'Temperature', 'Molecular_Weight', 'Specific_Heat_Ratio', 'Compress_Factor',

                                'Nominal_Pipe_Size', 'Inside_Pipe_Size',

                                'Schedule_No', 'Straight_Length', 'Equivalent_Length_Input', 'Fitting_Length',

                                'Fitting_K', 'Equivalent_Length_Cal', 'Roughness', 'Limitation_Velocity',

                                'Limitation_Pressure_Drop',

                                'Velocity', 'Reynolds', 'Friction_Factor', 'Pressure_Drop', 'Pressure_Drop_Friction',

                                'Pressure_Drop_Static', 'Pressure_Pipe_End_Point', 'Power']

                        values = ['?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',

                                  '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?']

                        param = (

                        str(data.uid), str(data.components_uid), data.stream_no, data.phase_type, data.flowrate_mass,

                        data.flowrate_volume, data.density,

                        data.viscosity, data.temperature, data.molecular_weight, data.specific_heat_ratio,

                        data.compress_factor, data.nominal_pipe_size,

                        data.inside_pipe_size, data.schedule_no, data.straight_length, data.equivalent_length_input,

                        data.fitting_length, data.fitting_K, data.equivalent_length_cal, data.roughness,

                        data.limitation_velocity,

                        data.limitation_pressure_drop, data.velocity, data.reynolds, data.friction_factor,

                        data.pressure_drop, data.pressure_drop_friction,

                        data.pressure_drop_static, data.pressure_pipe_end_point, data.power)

                        sql = 'insert or replace into HMB({}) values({})'.format(','.join(cols), ','.join(values))

                        cursor.execute(sql, param)

                    else:

                        sql = "delete from HMB where uid=?"

                        param = (data.uid,)

                        cursor.execute(sql, param)

                conn.commit()

            # Catch the exception

            except Exception as ex:

                from App import App

                from AppDocData import MessageType

                # Roll back any change if something goes wrong

                conn.rollback()

                message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

    '''

        @brief      return stream no collection which are not duplicated 

        @author     humkyung

        @date       2018.07.12

    '''

    def streamNos(self):

        return set([hmb.stream_no for hmb in self._hmbs if hmb.isDeleted == False]) if self._hmbs is not None else {}

    '''

        @brief      return given index's data

        @author     humkyung

        @date       2018.07.12

    '''

    def dataOfStreamNo(self, streamNo):

        return [hmb for hmb in self._hmbs if

                hmb.streamNo == streamNo and hmb.isDeleted == False] if self._hmbs is not None else None

    '''

        @brief      append hmb data

        @author     humkyung

        @date       2018.07.12

    '''

    def append(self, hmbData):

        if self._hmbs is None:

            self._hmbs = []

        self._hmbs.append(hmbData)

    '''

        @brief      reset

        @author     humkyung

        @date       2018.07.12

    '''

    def reset(self):

        if self._hmbs is not None:

            del self._hmbs

        self._hmbs = None

    def get_hmb_data(self, component_uid):

        """ get hmb data has given stream no """

        matches = [data for data in self._hmbs if data._components_uid == component_uid]

        return matches[0] if matches else None