Esempio n. 1
0
    def __calc_dvdp_msecpam__(self):
        """
        Рассчитывается производная скорости смеси (без проскальзывания - vm) по давлению

        Необходимо в дальнейшем для определения градиента скорости смеси
        :return: dv/dp
        """

        delta_p_bar = uc.Pa2bar(10)
        p2_bar = self.p_bar + delta_p_bar
        p1_bar = self.p_bar - delta_p_bar
        self.__calc_velosities__(p2_bar, self.t_c)
        v2_msec = self.vm_msec
        self.__calc_velosities__(p1_bar, self.t_c)
        v1_msec = self.vm_msec

        self.__calc_velosities__(self.p_bar, self.t_c)
        return (v2_msec - v1_msec) / 2 / uc.bar2Pa(delta_p_bar)
    def calc_grad(self, p_bar, t_c):
        """
        Функция для расчета градиента давления по методу Беггз и Брилл

        :param p_bar: давление, бар
        :param t_c: температура, С
        :return: градиент давления, Па /м
        """
        self.p_pa = uc.bar2Pa(p_bar)
        self.t_c = t_c
        if self.p_pa <= 0:
            self.result_grad_pam = 0
            return 0
        else:

            self.val_number_Fr = self.vm_msec**2 / const_g_m2sec / self.d_m  # (4.109)

            number_Fr = self.val_number_Fr

            CL = self.liquid_content
            L1 = 316 * CL**0.302
            L2 = 0.0009252 * CL**(-2.4684)
            L3 = 0.1 * CL**(-1.4516)
            L4 = 0.5 * CL**(-6.738)
            if (CL < 0.01 and number_Fr < L1) or (CL >= 0.01
                                                  and number_Fr < L2):
                # Segregated Flow - разделенный режим
                self.flow_regime = 0
            if (0.01 <= CL < 0.4
                    and L3 < number_Fr <= L1) or (CL >= 0.4
                                                  and L3 < number_Fr <= L4):
                # Intermittent Flow - прерывистый режим
                self.flow_regime = 1
            if (CL < 0.4 and number_Fr >= L1) or (CL >= 0.4
                                                  and number_Fr > L4):
                # Distributed Flow - распределенный режим
                self.flow_regime = 2
            if L2 <= number_Fr < L3 and CL >= 0.01:
                # Transition Flow - переходный режим
                self.flow_regime = 3

            if self.flow_regime != 3:
                self.__calc_hltetta__()
            else:
                self.flow_regime = 0
                self.__calc_hltetta__()
                hltetta_segr = self.liquid_content_with_Pains_cor
                self.flow_regime = 1
                self.__calc_hltetta__()
                hltetta_inter = self.liquid_content_with_Pains_cor
                A = (L3 - self.val_number_Fr) / (L3 - L2)
                B = 1 - A
                self.liquid_content_with_Pains_cor = (A * hltetta_segr +
                                                      B * hltetta_inter)

            self.number_Re = self.rhon_kgm3 * self.vm_msec * self.d_m / self.mun_pas

            self.friction_coefficient = self.module_friction.calc_f(
                self.number_Re, self.epsilon_friction_m, self.d_m)

            self.y = self.liquid_content / self.liquid_content_with_Pains_cor**2
            if 1 < self.y < 1.2:
                self.s = math.log(2.2 * self.y - 1.2)
            elif 1 == self.y:
                self.s = 0
            else:
                lny = math.log(self.y)
                self.s = lny / (-0.0523 + 3.182 * lny - 0.8725 * lny**2 +
                                0.01853 * lny**4)

            self.result_friction = self.friction_coefficient * math.exp(self.s)

            self.Ek = self.vm_msec * self.vsg_msec * self.rhon_kgm3 / self.p_pa

            self.rhos_kgm3 = (
                self.rho_liq_kgm3 * self.liquid_content_with_Pains_cor +
                self.rho_gas_kgm3 * (1 - self.liquid_content_with_Pains_cor))

            self.result_grad_pam = (
                (self.result_friction * self.rhon_kgm3 * self.vm_msec**2 / 2 /
                 self.d_m +
                 self.rhos_kgm3 * const_g_m2sec * math.sin(self.angle_rad)) /
                (1 - self.Ek))

            self.friction_grad_pam = (self.result_friction * self.rhon_kgm3 *
                                      self.vm_msec**2 / 2 / self.d_m)

            self.density_grad_pam = self.rhos_kgm3 * const_g_m2sec * math.sin(
                self.angle_rad)

            self.friction_grad_part_percent = self.friction_grad_pam / (
                1 - self.Ek) / self.result_grad_pam * 100

            self.density_grad_part_percent = self.density_grad_pam / (
                1 - self.Ek) / self.result_grad_pam * 100

            return self.result_grad_pam
Esempio n. 3
0
    def calc(self, p_bar, t_c):
        self.p_intake_bar = p_bar
        self.t_intake_bar = t_c

        self.p_bar = p_bar
        self.t_c = t_c

        self.power_fluid_stage_wt = 0
        self.power_fluid_total_wt = 0
        self.power_ESP_stage_wt = 0
        self.power_ESP_total_wt = 0
        self.dt_stage_c = 0
        self.dt_total_c = 0
        self.dp_stage_bar = 0
        self.dp_total_bar = 0
        self.stage_head_m = 0
        self.ESP_head_total_m = 0

        self.esp_calc_data.clear_data()
        self.fluid_flow_calc_data.clear_data()
        self.fluid_calc_data.clear_data()

        for i in range(self.stage_number):
            self.fluid.calc(self.p_bar, self.t_c)
            self.fluid_flow.calc(self.p_bar, self.t_c)

            self.gas_fraction_d = (
                self.fluid_flow.qgas_m3day * (1 - self.k_sep_total_d) /
                (self.fluid_flow.qliq_m3day + self.fluid_flow.qgas_m3day *
                 (1 - self.k_sep_total_d)))

            self.q_mix_m3day = self.fluid_flow.qliq_m3day + self.fluid_flow.qgas_m3day * (
                1 - self.k_sep_total_d)
            self.q_mix_degr_m3day = self.q_mix_m3day * (
                1 + self.k_rate_degradation_d)
            self.mu_mix_cP = self.fluid_flow.mu_liq_cP * (1 - self.gas_fraction_d) + \
                             self.fluid_flow.fl.mu_gas_cP * self.gas_fraction_d
            self.rho_mix_kgm3 = self.fluid_flow.rho_liq_kgm3 * (1 - self.gas_fraction_d) + \
                                self.fluid_flow.fl.rho_gas_kgm3 * self.gas_fraction_d
            self.stage_head_m = self.get_ESP_head_m(self.q_mix_degr_m3day,
                                                    self.stage_number_in_calc,
                                                    self.mu_mix_cP)
            self.ESP_head_total_m += self.stage_head_m
            self.dp_stage_bar = uc.Pa2bar(self.stage_head_m *
                                          self.rho_mix_kgm3 * uc.g)
            self.dp_total_bar += self.dp_stage_bar

            self.power_fluid_stage_wt = uc.m3day2m3sec(
                self.q_mix_degr_m3day) * uc.bar2Pa(self.dp_stage_bar)
            self.power_fluid_total_wt += self.power_fluid_stage_wt

            self.power_ESP_stage_wt = self.get_ESP_power_Wt(
                self.q_mix_degr_m3day, self.stage_number_in_calc,
                self.mu_mix_cP)
            self.power_ESP_total_wt += self.power_ESP_stage_wt

            if self.power_ESP_total_wt > 0:
                self.ESP_efficiency_total_d = self.power_fluid_total_wt / self.power_ESP_total_wt
            if self.power_ESP_stage_wt > 0:
                self.ESP_efficiency_stage_d = self.power_fluid_stage_wt / self.power_ESP_stage_wt

            if self.ESP_efficiency_stage_d > 0:
                self.dt_stage_c = (uc.g * self.stage_head_m /
                                   self.fluid_flow.heatcapn_jkgc *
                                   (1 - self.ESP_efficiency_stage_d) /
                                   self.ESP_efficiency_stage_d)

            self.dt_total_c += self.dt_stage_c

            if self.save_calculated_data:
                self.esp_calc_data.save_data_from_class_to_storage(self)
                self.fluid_flow_calc_data.save_data_from_class_to_storage(
                    self.fluid_flow)
                self.fluid_calc_data.save_data_from_class_to_storage(
                    self.fluid)

            self.p_bar += self.dp_stage_bar
            self.t_c += self.dt_stage_c
    def calc_grad(self, p_bar, t_c):
        """
        Функция для расчета градиента давления по методу Беггз и Брилл

        :param p_bar: давление, бар
        :param t_c: температура, С
        :return: градиент давления, Па /м
        """
        self.p_pa = uc.bar2Pa(p_bar)
        self.t_c = t_c
        if self.p_pa <= 0:
            self.result_grad_pam = 0
            return 0
        else:
            self.val_number_Fr = self.vm_msec**2 / const_g_m2sec / self.d_m  # (4.109)

            self.flow_regime = self.determine_flow_pattern(
                self.val_number_Fr, self.liquid_content)

            if self.flow_regime != 3:
                self.__calc_hltetta__()
            else:
                self.flow_regime = 0
                self.__calc_hltetta__()
                hltetta_segr = self.liquid_content_with_Pains_cor
                self.flow_regime = 1
                self.__calc_hltetta__()
                hltetta_inter = self.liquid_content_with_Pains_cor
                A = (self.L3 - self.val_number_Fr) / (self.L3 - self.L2)
                B = 1 - A
                self.liquid_content_with_Pains_cor = A * hltetta_segr + B * hltetta_inter
                self.flow_regime = 3

            self.number_Re = self.rhon_kgm3 * self.vm_msec * self.d_m / self.mun_pas

            self.friction_coefficient = self.module_friction.calc_f(
                self.number_Re, self.epsilon_friction_m, self.d_m)

            self.y = self.liquid_content / self.liquid_content_with_Pains_cor**2
            if 1 < self.y < 1.2:
                self.s = math.log(2.2 * self.y - 1.2)
            elif 1 == self.y:
                self.s = 0
            else:
                lny = math.log(self.y)
                self.s = lny / (-0.0523 + 3.182 * lny - 0.8725 * lny**2 +
                                0.01853 * lny**4)

            self.result_friction = self.friction_coefficient * math.exp(self.s)

            if self.acceleration_grad_using == 0:
                self.Ek = 0  # TODO дополнительно можно сделать градиент на ускорение
            else:
                self.Ek = self.vm_msec * self.vsg_msec * self.rhon_kgm3 / self.p_pa

            self.rhos_kgm3 = (
                self.rho_liq_kgm3 * self.liquid_content_with_Pains_cor +
                self.rho_gas_kgm3 * (1 - self.liquid_content_with_Pains_cor))

            self.friction_grad_pam = (self.result_friction * self.rhon_kgm3 *
                                      self.vm_msec**2 / 2 /
                                      self.d_m) * self.friction_grad_coef

            self.density_grad_pam = self.rhos_kgm3 * const_g_m2sec * math.sin(
                self.angle_rad) * self.gravity_grad_coef

            self.result_grad_pam = (
                (self.friction_grad_pam + self.density_grad_pam) /
                (1 - self.Ek) * self.acceleration_grad_coef)

            self.acceleration_grad_pam = self.result_grad_pam * self.Ek

            self.friction_grad_part_percent = self.friction_grad_pam / self.result_grad_pam * 100

            self.density_grad_part_percent = self.density_grad_pam / self.result_grad_pam * 100

            self.acceleration_grad_part_percent = self.acceleration_grad_pam / self.result_grad_pam * 100

            self.gas_fraction_real_d = 1 - self.liquid_holdup_d

            return self.result_grad_pam