Example #1
0
        /// <summary>
        /// Atualiza o valor da vazão [m^3/s] da bomba utilizando a equação de Bernoulli.
        /// </summary>
        /// <param name="fluido">O fluido que está passando na bomba. </param>
        /// <param name="tubulacao">A tubulação que está sendo analisada. </param>
        /// <returns> A altura da bomba [m]. </returns>
        public void CalculaVazao(Fluido fluido, Tubulacao tubulacao)
        {
            double vazao = 0.001;
            double eps   = 10E-6;
            double err;
            double deri;
            double fX;
            double nIte = 1;

            fX   = this.CalcAlturaBomba(vazao) - tubulacao.CalculaPerdaCarga(fluido, vazao);
            err  = Math.Abs(fX);
            deri = ((this.CalcAlturaBomba(vazao + eps) - tubulacao.CalculaPerdaCarga(fluido, vazao + eps))
                    - (this.CalcAlturaBomba(vazao - eps) - tubulacao.CalculaPerdaCarga(fluido, vazao - eps))) / (2 * eps);
            Console.WriteLine("deri = {0}", deri);

            while (err > 10E-6)
            {
                vazao = vazao - (fX / deri);
                Console.WriteLine("vazão Iter = {0}", vazao);
                fX   = this.CalcAlturaBomba(vazao) - tubulacao.CalculaPerdaCarga(fluido, vazao);
                deri = ((this.CalcAlturaBomba(vazao + eps) - tubulacao.CalculaPerdaCarga(fluido, vazao + eps))
                        - (this.CalcAlturaBomba(vazao - eps) - tubulacao.CalculaPerdaCarga(fluido, vazao - eps))) / (2 * eps);
                Console.WriteLine("fX Iter = {0}", fX);

                err  = Math.Abs(fX);
                nIte = nIte + 1;
            }

            this.vazao             = vazao;
            this.alturaManometrica = CalcAlturaBomba(vazao);

            Console.WriteLine("====Altura Final: {0}", this.alturaManometrica);
            Console.WriteLine("====Perda de carga Final: {0}", tubulacao.CalculaPerdaCarga(fluido, vazao));
        }
Example #2
0
        /// <summary>
        /// Calcula o número de Reyolds
        /// </summary>
        /// <param name="fluido">O Fluido que está na tubulação. </param>
        /// <param name="vazao">A vazão do fluido [m^3/s]. </param>
        /// <returns> O número de Rynolds [adm]. </returns>
        public double CalcReynolds(Fluido fluido, double vazao)
        {
            double re;

            re = (4 * fluido.densidade * vazao) / (Math.PI * fluido.viscosidade * this.diametro);

            return(re);
        }
Example #3
0
        /// <summary>
        /// Cálcula a perda de carga da tubulação
        /// </summary>
        /// <param name="fluido">O Fluido que está na tubulação. </param>
        /// <param name="vazao">A vazão do fluido [m^3/s]. </param>
        /// <returns> A perda de carga [m]. </returns>
        public double CalculaPerdaCarga(Fluido fluido, double vazao)
        {
            double fAtrito         = CalcFAtrito(fluido, vazao);
            double comprimetoTotal = this.comprimento + this.comprimentoEquivalente;
            double hf1             = (32 / Math.Pow(Math.PI, 2));
            double hf2             = fAtrito * comprimetoTotal * Math.Pow(vazao, 2) / (Math.Pow(this.diametro, 5.0) * g);

            this.perdaCarga = hf1 * hf2;

            return(this.perdaCarga);
        }
Example #4
0
        /// <summary>
        /// Calcula o fator de atrito de acordo com a correlação de Fanning.
        /// </summary>
        /// <param name="fluido">O Fluido que está na tubulação. </param>
        /// <param name="vazao">A vazão do fluido [m^3/s]. </param>
        /// <returns> O fator de atrito [adm]. </returns>
        public double CalcFAtrito(Fluido fluido, double vazao)
        {
            double Re = CalcReynolds(fluido, vazao);
            double A1 = Math.Pow(7 / Re, 0.9);
            double A2 = 0.27 * this.rugosidadeRelativa;
            double A  = Math.Pow(-2.475 * Math.Log(A1 + A2), 16);
            double B  = Math.Pow((37530 / Re), 16.0);

            double fA1 = Math.Pow(8 / Re, 12);
            double fA2 = 1 / Math.Pow(A + B, 3.0 / 2.0);

            double fA = 2 * Math.Pow(fA1 + fA2, 1.0 / 12.0);

            //Console.WriteLine("fA = {0}", fA);

            return(fA);
        }
Example #5
0
        static void Main()
        {
            // This is a hello world commentary.
            // Console.WriteLine("Hellow World!!");

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new FormsMaster());

            Fluido agua = new Fluido
            {
                densidade   = 1000,
                viscosidade = 8.90E-4,
            };

            Tubulacao tubo1 = new Tubulacao
            {
                diametro    = 0.05,
                rugosidade  = 4.572E-5,
                comprimento = 10
            };

            tubo1.rugosidadeRelativa = tubo1.rugosidade / tubo1.diametro;

            Singularidade s1 = new Singularidade
            {
                comprimentoEqv = 1
            };

            Singularidade s2 = new Singularidade
            {
                comprimentoEqv = 1
            };

            List <Singularidade> lista = new List <Singularidade>
            {
                s1,
                s2
            };

            foreach (Singularidade sin in lista)
            {
                tubo1.listaSingulariedades.Add(sin);
            }

            tubo1.ComprEqSing();

            Bomba bomba1 = new Bomba
            {
                equacaoCurva = new double[] { 0, -2096928, 2649.96, 26 }
            };

            Bomba bomba2 = new Bomba
            {
                equacaoCurva = new double[] { 1, 2096928, -2650.96, 4 }
            };

            Bomba bombaEq = new Bomba
            {
            };

            Bomba[] arrayBombas = new Bomba[] { bomba1, bomba2 };

            bombaEq.BombaEquivalente(new Bomba[] { bomba1, bomba2 }, "Série");

            /*
             * Console.WriteLine("==========Dados da Simulação========");
             * Console.WriteLine("===>Fluido");
             * Console.WriteLine("Densidade : {0} Kg/m^3", agua.densidade);
             * Console.WriteLine("Viscosidade : {0} Pa*s", agua.viscosidade);
             * Console.WriteLine("===>Tubulação");
             * Console.WriteLine("Diametro : {0} m", tubo1.diametro);
             * Console.WriteLine("Comprimento : {0} m",tubo1.comprimento);
             * Console.WriteLine("Comprimento Eq das singularidades: {0} m", tubo1.comprimentoEquivalente);
             * Console.WriteLine("Comprimento total: {0} m", tubo1.comprimentoEquivalente + tubo1.comprimento);
             * Console.WriteLine("===>Bomba");
             * Console.WriteLine("Eq. da bomba: {0}*Q^3 + {1}*Q^2 + {2}*Q^1 + {3}",bomba1.equacaoCurva[0], bomba1.equacaoCurva[1], bomba1.equacaoCurva[2], bomba1.equacaoCurva[3]);
             * Console.WriteLine("Eq. da bombaEQ: {0}*Q^3 + {1}*Q^2 + {2}*Q^1 + {3}", bombaEq.equacaoCurva[0], bombaEq.equacaoCurva[1], bombaEq.equacaoCurva[2], bombaEq.equacaoCurva[3]);
             *
             * bomba1.CalculaVazao(agua, tubo1);
             *
             * Console.WriteLine("==========Resultados da Simulação========");
             * Console.WriteLine("Vazão : {0} m^3/h", bomba1.vazao * 3600);
             * Console.WriteLine("Perda de carga  : {0} m", tubo1.perdaCarga);
             * Console.WriteLine("Altura da bomba : {0} m", bomba1.alturaManometrica);
             *
             * Console.ReadLine();
             */
        }
Example #6
0
 /// <summary>
 /// Insere a perda de carga da tubulação conforme o fluido e vazão
 /// </summary>
 /// <param name="fluido">O Fluido que está na tubulação. </param>
 /// <param name="vazao">A vazão do fluido [m^3/s]. </param>
 public void SetPerdaCarga(Fluido fluido, double vazao)
 {
     this.perdaCarga = CalculaPerdaCarga(fluido, vazao);
 }