HYTOS

# -*- coding: utf-8 -*-

"""This is PressureVariation module"""

import sys

from PyQt5 import QtCore, QtGui, QtWidgets

from PyQt5.QtWidgets import *

import os

from AppDocData import AppDocData, Qt

import PressureVariation_UI

import math

def is_blank(s):

    return not (s and s.strip())

def is_float(s):

    try:

        if s:

            float(s)

            return True

        else:

            return False

    except ValueError:

        return False

def convert_to_fixed_point(value):

    if is_float(str(value)):

        tokens = f"{float(value):.10f}".split('.')

        if len(tokens) == 2:

            # 소수점 아래가 있을 경우 소수점 아래의 trailing zero를 제거한다.

            if is_blank(tokens[1].rstrip('0')):

                return tokens[0]

            else:

                tokens[1] = tokens[1].rstrip('0')

                return '.'.join(tokens)

        else:

            return tokens[0]

    else:

        return value

def set_item_properties(name, alignment, color=None):

    if name is None:

        name = ''

    item = QTableWidgetItem(str(name))

    item.setTextAlignment(alignment)

    if color:

        item.setBackground(color)

    return item

def is_not_blank(s):

    return bool(s and s.strip())

class QPressureVariation(QDialog):

    def __init__(self):

        QDialog.__init__(self)

        self.ui = PressureVariation_UI.Ui_Dialog()

        self.ui.setupUi(self)

        self.ui.buttonBox.button(QDialogButtonBox.Ok).setIcon(QtGui.QIcon(':/images/OK.svg'))

        self.ui.buttonBox.button(QDialogButtonBox.Cancel).setIcon(QtGui.QIcon(':/images/Cancel.svg'))

        self.units = None

        self.item = None

        self.init_units()

        self.initialize()

    def show_dialog(self, item):

        self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)

        self.item = item

        self.load_data()

        self.load_regime()

        return self.exec_()

    def init_units(self):

        app_doc_data = AppDocData.instance()

        active_drawing = app_doc_data.activeDrawing

        for attr in active_drawing.attrs:

            if attr[0] == 'Units':

                self.units = attr[1]

    def initialize(self):

        self.ui.tableWidget.setColumnCount(23)

        col_names = ['No.\n-', 'Element\n-', 'Diameter\n{}'.format(self.units['Pipe_Diameter']),

                     'Length\n{}'.format(self.units['Length']), 'Angle\n(deg)', 'K\n-',

                     'Pressure\n{}(g)'.format(self.units['Pressure']), 'Void\n-', 'Quality\n-',

                     'Mean.Den\n{}'.format(self.units['Density']), 'Homo.Den\n{}'.format(self.units['Density']),

                     'V.Den\n{}'.format(self.units['Density']), 'Mean Vel\n{}'.format(self.units['Velocity']),

                     'Homo Vel\n{}'.format(self.units['Velocity']), 'Max Vel\n{}'.format(self.units['Velocity']),

                     'Ero Vel\n{}'.format(self.units['Velocity']), 'Pattern\nX', 'Pattern\nY', 'Regime\n-',

                     'Friction\n{}/{}'.format(self.units['Pressure'], self.units['Length']),

                     'Gravity\n{}/{}'.format(self.units['Pressure'], self.units['Length']),

                     'Momentum\n{}/{}'.format(self.units['Pressure'], self.units['Length']),

                     'Total\n{}'.format(self.units['Pressure'])]

        self.ui.tableWidget.setHorizontalHeaderLabels(col_names)

        self.ui.tableWidget.verticalHeader().setVisible(False)

        self.ui.tableWidget.setSelectionMode(QAbstractItemView.SingleSelection)

        self.ui.tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.ui.tableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)

        self.ui.tableWidget.horizontalHeader().setStretchLastSection(True)

        self.ui.label_Total_Pressure_Drop_Unit.setText(self.units['Pressure'])

        self.ui.label_Pipe_Friction_Loss_Unit.setText(self.units['Pressure'])

        self.ui.label_Static_Loss_Gain_Unit.setText(self.units['Pressure'])

        self.ui.label_Elbow_Loss_Unit.setText(self.units['Pressure'])

        self.ui.label_Valve_Loss_Unit.setText(self.units['Pressure'])

        self.ui.label_Nozzle_Loss_Unit.setText(self.units['Pressure'])

    def add_data(self, data):

        try:

            row = self.ui.tableWidget.rowCount()

            self.ui.tableWidget.setRowCount(row + 1)

            self.ui.tableWidget.setItem(row, 0, set_item_properties(row, Qt.AlignHCenter | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 1, set_item_properties(convert_to_fixed_point(data[0]),

                                                                    Qt.AlignLeft | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 2, set_item_properties(convert_to_fixed_point(data[1]),

                                                                    Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 3, set_item_properties(convert_to_fixed_point(data[2]),

                                                                    Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 4, set_item_properties(convert_to_fixed_point(data[3]),

                                                                    Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 5, set_item_properties(convert_to_fixed_point(data[4]),

                                                                    Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 6, set_item_properties(convert_to_fixed_point(data[5]),

                                                                    Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 7, set_item_properties(convert_to_fixed_point(data[6]),

                                                                    Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 8, set_item_properties(convert_to_fixed_point(data[7]),

                                                                    Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 9, set_item_properties(convert_to_fixed_point(data[8]),

                                                                    Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 10, set_item_properties(convert_to_fixed_point(data[9]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 11, set_item_properties(convert_to_fixed_point(data[10]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 12, set_item_properties(convert_to_fixed_point(data[11]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 13, set_item_properties(convert_to_fixed_point(data[12]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 14, set_item_properties(convert_to_fixed_point(data[13]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 15, set_item_properties(convert_to_fixed_point(data[14]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 16, set_item_properties(convert_to_fixed_point(data[15]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 17, set_item_properties(convert_to_fixed_point(data[16]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 18, set_item_properties(convert_to_fixed_point(data[17]),

                                                                     Qt.AlignHCenter | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 19, set_item_properties(convert_to_fixed_point(data[18]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 20, set_item_properties(convert_to_fixed_point(data[19]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 21, set_item_properties(convert_to_fixed_point(data[20]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.setItem(row, 22, set_item_properties(convert_to_fixed_point(data[21]),

                                                                     Qt.AlignRight | Qt.AlignVCenter))

            self.ui.tableWidget.resizeRowsToContents()

            self.ui.tableWidget.resizeColumnsToContents()

        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)

    def load_regime(self):

        try:

            for row in range(self.ui.tableWidget.rowCount()):

                length = self.ui.tableWidget.item(row, 3).text()

                if is_not_blank(length):

                    x = float(self.ui.tableWidget.item(row, 16).text())

                    y = float(self.ui.tableWidget.item(row, 17).text())

                    angle = float(self.ui.tableWidget.item(row, 4).text())

                    if angle == 0:

                        # Horizontal

                        left = 32 + (204 / (7 + 5)) * (math.log10(x) + 5)

                        top = 270 - (242 / (5 + 9)) * (math.log10(y) + 9)

                        label = QtWidgets.QLabel(self.ui.groupBox_4)

                        label.setText('■')

                        label.setStyleSheet('QLabel {color: blue;}')

                        label.setGeometry(QtCore.QRect(left, top, 8, 8))

                    elif angle > 0:

                        # Vertical Upward

                        left = 35 + (209 / (7 - (-2))) * (math.log10(x) - (-2))

                        top = 269 - (237 / (8 - (-5))) * (math.log10(y) - (-5))

                        label = QtWidgets.QLabel(self.ui.groupBox_3)

                        label.setText('■')

                        label.setStyleSheet('QLabel {color: blue;}')

                        label.setGeometry(QtCore.QRect(left, top, 8, 8))

                    elif angle < 0:

                        # Vertical Downward

                        left = 33 + (198 / (20 - 0)) * (x - 0)

                        top = 269 - (241 / (24 - 2)) * (y - 2)

                        label = QtWidgets.QLabel(self.ui.groupBox_5)

                        label.setText('■')

                        label.setStyleSheet('QLabel {color: blue;}')

                        label.setGeometry(QtCore.QRect(left, top, 8, 8))

        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)

    def load_data(self):

        try:

            self.ui.listWidget_Status.clear()

            # For Calculation Summary

            total_display = 0

            fric_display_pipe = 0

            grav_display_pipe = 0

            dp_display_bend = 0

            dp_display_valve = 0

            dp_display_noz = 0

            no = 0

            find_velocity_20 = False

            for row in self.item.mixed_pressure_variation:

                data = list(row)

                data[0] = row[0]  # element

                data[1] = row[1]  # diameter

                data[2] = round(row[2], 3) if row[2] is not None else None  # length

                data[3] = row[3]  # angle

                data[4] = round(row[4], 3) if row[4] is not None else None  # k

                data[5] = round(row[5], 3) if row[5] is not None else None  # pressure

                data[6] = round(row[6], 3) if row[6] is not None else None  # void

                data[7] = round(row[7], 3) if row[7] is not None else None  # quality

                data[8] = round(row[8], 3) if row[8] is not None else None  # density

                data[9] = round(row[9], 3) if row[9] is not None else None  # homo_den 새로 추가됨

                data[10] = round(row[10], 3) if row[10] is not None else None  # v_den Index 9 -> 10로 변경

                data[11] = round(row[11], 3) if row[11] is not None else None  # mean_vel Index 10 -> 11로 변경

                data[12] = round(row[12], 3) if row[12] is not None else None  # homo_den 새로 추가됨

                data[13] = round(row[13], 3) if row[13] is not None else None  # max_vel Index 11 -> 13로 변경

                data[14] = round(row[14], 3) if row[14] is not None else None  # ero_vel Index 12 -> 14로 변경

                data[15] = round(row[15], 5) if row[15] is not None else None  # x Index 13 -> 15로 변경

                data[16] = round(row[16], 5) if row[16] is not None else None  # y Index 14 -> 16로 변경

                # data[15] = round(row[15], 3) if row[15] is not None else None  # x Index 13 -> 15로 변경

                # data[16] = round(row[16], 3) if row[16] is not None else None  # y Index 14 -> 16로 변경

                data[17] = row[17]  # regime Index 15 -> 17로 변경

                data[18] = round(row[18], 5) if row[18] is not None else None  # friction Index 16 -> 18로 변경

                data[19] = round(row[19], 5) if row[19] is not None else None  # gravity Index 17 -> 19로 변경

                data[20] = round(row[20], 5) if row[20] is not None else None  # momentum Index 18 -> 20로 변경

                data[21] = round(row[21], 5) if row[21] is not None else None  # total Index 19 -> 21로 변경

                total_display += round(row[21], 5) if row[21] is not None else 0

                len = row[2] if row[2] is not None else 0

                fric = row[18] if row[18] is not None else 0

                grav = row[19] if row[19] is not None else 0

                fric_display_pipe += round(fric * len, 5)

                grav_display_pipe += round(grav * len, 5)

                if str(row[0]) != 'Start Point':

                    element = str(row[0]).rsplit('_', 1)[1]

                    if element == 'Bend':

                        dp_display_bend += round(row[21], 5) if row[21] is not None else 0

                    elif element in ('Check_Valve', 'Ball Valve', 'Gate Valve', 'Globe Valve', 'Butterfly Valve'):

                        dp_display_valve += round(row[21], 5) if row[21] is not None else 0

                    elif element in ('Nozzle In', 'Nozzle Out'):

                        dp_display_noz += round(row[21], 5) if row[21] is not None else 0

                mean_vel = row[11] if row[11] is not None else 0

                max_vel = row[13] if row[13] is not None else 0

                if float(mean_vel) >= 20:

                    find_velocity_20 = True

                if float(max_vel) < float(mean_vel):

                    # str(row[0]).split('_', 1)[0]

                    message = '{} velocity is higher than maximum velocity!'.format(row[0])

                    item = QListWidgetItem(message)

                    item.setForeground(Qt.black)

                    self.ui.listWidget_Status.insertItem(0, item)

                regime = str(row[17])

                if regime in ('Slug / Plug', 'Oscillary', 'Churn', 'Plug'):

                    message = '{} regime is {}!'.format(row[0], regime)

                    item = QListWidgetItem(message)

                    item.setForeground(Qt.black)

                    self.ui.listWidget_Status.insertItem(0, item)

                self.add_data(data)

                no += 1

            self.ui.lineEdit_Total_Pressure_Drop.setText(str(round(total_display, 5)))

            self.ui.lineEdit_Pipe_Friction_Loss.setText(str(round(fric_display_pipe, 5)))

            self.ui.lineEdit_Static_Loss_Gain.setText(str(round(grav_display_pipe, 5)))

            self.ui.lineEdit_Elbow_Loss.setText(str(round(dp_display_bend, 5)))

            self.ui.lineEdit_Valve_Loss.setText(str(round(dp_display_valve, 5)))

            self.ui.lineEdit_Nozzle_Loss.setText(str(round(dp_display_noz, 5)))

            if find_velocity_20:

                message = "Velocity is not OK"

                item = QListWidgetItem(message)

                item.setForeground(Qt.black)

                self.ui.listWidget_Status.insertItem(0, item)

                self.ui.listWidget_Status.setStyleSheet('background-color:rgb(255, 0, 0)')

            elif self.ui.listWidget_Status.count() > 0:

                message = "Calculation result is not available !"

                item = QListWidgetItem(message)

                item.setForeground(Qt.black)

                self.ui.listWidget_Status.insertItem(0, item)

                self.ui.listWidget_Status.setStyleSheet('background-color:rgb(255, 0, 0)')

            else:

                message = "Regime is OK.\nVelocity is OK."

                item = QListWidgetItem(message)

                item.setForeground(Qt.black)

                self.ui.listWidget_Status.insertItem(0, item)

                self.ui.listWidget_Status.setStyleSheet('background-color:rgb(54, 163, 85)')

        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)

    def accept(self):

        QDialog.accept(self)

    def reject(self):

        QDialog.reject(self)