Ejemplo n.º 1
0
        private void horizontalToolStripMenuItem_Click(object sender, EventArgs e)
        {
            clsHorizontal TrechoHorizontal = new clsHorizontal();
            frmTrecho     NovoTrecho       = new frmTrecho(frmTrecho.TipoJanela.Novo, frmTrecho.TipoDeTrecho.Horizontal, TrechoHorizontal);
            DialogResult  DR = NovoTrecho.ShowDialog();

            if (DR == DialogResult.OK)
            {
                TrechoHorizontal.PC = DPGLH(TrechoHorizontal);

                Calculo.Trechos.Add(TrechoHorizontal);

                if (Status != Modo.Novo)
                {
                    SetStatus(Modo.Alterado);

                    TituloAlterado();
                }

                AtualizaTabela();
            }
            else
            {
            }
        }
Ejemplo n.º 2
0
        private void btToolCopy_Click(object sender, EventArgs e)
        {
            object Item = new object();

            Item = Calculo.Trechos[gridTrechos.CurrentRow.Index];

            if (Item is clsHorizontal)
            {
                clsHorizontal CopyH = new clsHorizontal();

                CopyH.Nome  = ((clsHorizontal)Item).Nome;
                CopyH.D     = ((clsHorizontal)Item).D;
                CopyH.L     = ((clsHorizontal)Item).L;
                CopyH.FLOWG = ((clsHorizontal)Item).FLOWG;
                CopyH.FLOWL = ((clsHorizontal)Item).FLOWL;
                CopyH.RHOG  = ((clsHorizontal)Item).RHOG;
                CopyH.RHOL  = ((clsHorizontal)Item).RHOL;
                CopyH.VISCG = ((clsHorizontal)Item).VISCG;
                CopyH.VISCL = ((clsHorizontal)Item).VISCL;
                CopyH.SIGMA = ((clsHorizontal)Item).SIGMA;
                CopyH.RF    = ((clsHorizontal)Item).RF;
                CopyH.PC    = ((clsHorizontal)Item).PC;

                CopyH.EPS = ((clsVertical)Item).EPS;

                Calculo.Trechos.Add(CopyH);
            }
            else
            {
                clsVertical CopyV = new clsVertical();

                CopyV.Nome  = ((clsVertical)Item).Nome;
                CopyV.D     = ((clsVertical)Item).D;
                CopyV.L     = ((clsVertical)Item).L;
                CopyV.FLOWG = ((clsVertical)Item).FLOWG;
                CopyV.FLOWL = ((clsVertical)Item).FLOWL;
                CopyV.RHOG  = ((clsVertical)Item).RHOG;
                CopyV.RHOL  = ((clsVertical)Item).RHOL;
                CopyV.VISCG = ((clsVertical)Item).VISCG;
                CopyV.VISCL = ((clsVertical)Item).VISCL;
                CopyV.SIGMA = ((clsVertical)Item).SIGMA;
                CopyV.EPS   = ((clsVertical)Item).EPS;
                CopyV.P     = ((clsVertical)Item).P;
                CopyV.PC    = ((clsVertical)Item).PC;

                Calculo.Trechos.Add(CopyV);
            }



            if (Status != Modo.Novo)
            {
                SetStatus(Modo.Alterado);

                TituloAlterado();
            }

            AtualizaTabela();
        }
Ejemplo n.º 3
0
        private double DPGLH(clsHorizontal TrechoH)
        {
            int ItMax = 50;
            int Iter;

            double Area;
            double USL;
            double USG;
            double GT;
            double LAMBDA;
            double FR;
            double RL;
            double RE;
            double Delta;
            double Beta;
            double F;
            double DBDT;
            double FP;
            double DRL;
            double VISCTP;
            double RHOTP;
            double UTP;
            double rDPGLH = 0;
            double IFR;
            double XMG;
            double C;
            double TERM;
            double UT;
            double REL;
            double REG;
            double DELPL;
            double DELPG;
            double X;

            Area = (Math.PI * Math.Pow(TrechoH.D, 2)) / 4;
            USL  = TrechoH.FLOWL / (Area * TrechoH.RHOL);
            USG  = TrechoH.FLOWG / (Area * TrechoH.RHOG);
            GT   = (TrechoH.FLOWL + TrechoH.FLOWG) / Area;

            if (GT <= 2700)
            {
                // Identificando o Padrão de Escoamento

                IFR = IGL(USL, USG, TrechoH.RHOL, TrechoH.RHOG, TrechoH.VISCL, TrechoH.VISCG, TrechoH.SIGMA);

                if ((IFR != 4) && (IFR != 6))
                {
                    // Usando Correlação de Lockhart-Martinelli

                    REL = TrechoH.D * USL * TrechoH.RHOL / TrechoH.VISCL;
                    REG = TrechoH.D * USG * TrechoH.RHOG / TrechoH.VISCG;

                    if ((REL <= 1000) && (REG <= 1000))
                    {
                        C = 5;
                    }
                    else if ((REL > 1000) && (REG <= 1000))
                    {
                        C = 10;
                    }
                    else if ((REL <= 1000) && (REG > 1000))
                    {
                        C = 10;
                    }
                    else
                    {
                        C = 20;
                    }
                    DELPL  = PRDROP(TrechoH.D, USL, TrechoH.RHOL, TrechoH.VISCL, TrechoH.EPS, TrechoH.L);
                    DELPG  = PRDROP(TrechoH.D, USG, TrechoH.RHOG, TrechoH.VISCG, TrechoH.EPS, TrechoH.L);
                    X      = Math.Sqrt(DELPL / DELPG);
                    rDPGLH = DELPL * (1 + C / X + 1 / Math.Pow(X, 2));
                }
                else
                {
                    // Usando Correlação de Hoogendoorn para escoamento Ondulado ou Estratificado

                    XMG    = TrechoH.FLOWG / (TrechoH.FLOWL + TrechoH.FLOWG);
                    C      = 9.5 * Math.Pow(XMG, 0.5) - 62.6 * Math.Pow(XMG, 1.3);
                    TERM   = (1 + 230 * Math.Pow(XMG, 0.84)) * Math.Pow(1.38 * Math.Pow(10, -3) * TrechoH.RHOL / TrechoH.RHOG, C);
                    UT     = (TrechoH.FLOWG + TrechoH.FLOWL) / (Area * TrechoH.RHOL);
                    rDPGLH = PRDROP(TrechoH.D, UT, TrechoH.RHOL, TrechoH.VISCL, TrechoH.EPS, TrechoH.L);
                }
            }
            else
            {
                // Cálculo do Holdup usando Correlação de Hughmark

                LAMBDA = USL / (USL + USG);
                FR     = Math.Pow(USG + USL, 2) / (G * TrechoH.D);
                Iter   = 0;
                RL     = 1;
                while (Iter <= ItMax)
                {
                    RE    = TrechoH.D * GT / (RL * TrechoH.VISCL + (1 - RL) * TrechoH.VISCG);
                    Delta = Math.Pow(RE, 1 / 6) * Math.Pow(FR, 0.125) / Math.Pow(LAMBDA, 0.25);
                    if (Delta <= 10)
                    {
                        Beta = -0.16367 + Delta * (0.31037 + Delta * (-0.03525 + Delta * 0.001366));
                    }
                    else
                    {
                        Beta = 0.75545 + Delta * (0.003585 - Delta * 0.1463 * Math.Pow(10, -4));
                    }
                    F = RL - 1 + Beta * (1 - LAMBDA);
                    if (Math.Abs(F) <= Math.Pow(10, -5))
                    {
                        break;
                    }
                    else
                    {
                        if (Delta <= 10)
                        {
                            DBDT = 0.31037 + Delta * (-0.0705 + Delta * 0.004098);
                        }
                        else
                        {
                            DBDT = 0.003585 - 0.2872 * Math.Pow(10, -4) * Delta;
                        }
                        FP  = 1 * ((-Delta / 6) * (TrechoH.VISCL - TrechoH.VISCG) / (RL * TrechoH.VISCL - (1 - RL) * TrechoH.VISCG) * DBDT) * (1 - LAMBDA);
                        DRL = -F / FP;
                        if (Math.Abs(DRL) > (TrechoH.RF * RL))
                        {
                            DRL = ArrumaSinal((TrechoH.RF * RL), DRL);
                        }
                        RL = RL + DRL;
                    }
                    Iter = Iter + 1;
                }

                VISCTP = TrechoH.VISCL * Math.Exp(2.5 / (1 - 39 * (1 - RL) / 64));
                RHOTP  = LAMBDA * TrechoH.RHOL + (1 - LAMBDA) * TrechoH.RHOG;
                UTP    = GT / RHOTP;
                rDPGLH = PRDROP(TrechoH.D, UTP, RHOTP, VISCTP, TrechoH.EPS, TrechoH.L);
            }

            return(Math.Round(rDPGLH, 4, MidpointRounding.AwayFromZero));
        }