static void propGeometricasPerfilU(Perfil perfil)
        {
            double t         = perfil.PegarEspessura();
            double elemento1 = perfil.PegarElemento1();
            double elemento2 = perfil.PegarElemento2();
            double elemento3 = perfil.PegarElemento3();

            ycg = elemento3 * 0.5;

            area = t * (PerfilU.b1m + PerfilU.b2m + PerfilU.b3m + b4m + b5m);
            xg   = (b2m * t * (b2m + 2 * b1m)) / area; // Com relação a linha média da alma

            //Mesa
            double momentobx2 = (b2m * Math.Pow(t, 3)) / 12;
            double momentoby2 = (t * Math.Pow(b2m, 3)) / 12;;
            double areaB2     = b2m * t;
            double yB2        = ycg - t / 2; //Distancia do eixo até a linha media da mesa
            double xB2        = (0.5 * b2m) - xg;

            //Alma
            double momentobx3 = (t * Math.Pow(b3m, 3)) / 12;
            double momentoby3 = (b3m * Math.Pow(t, 3)) / 12;
            double areaB3     = b3m * t;
            double xb3        = xg;

            //Enrijecedores
            double momentobx1 = (t * Math.Pow(b1m, 3)) / 12;
            double momentoby1 = (b1m * Math.Pow(t, 3)) / 12;
            double areaB1     = b1m * t;
            double yB1        = ycg - (0.5 * t + b1m * 0.5);
            double xb1        = elemento2 - xg - t;

            //Momento em X
            iPerfilX = 2 * (momentobx2 + areaB2 * Math.Pow(yB2, 2)) + 2 * (momentobx1 + areaB1 * Math.Pow(yB1, 2))
                       + momentobx3;

            rx = Math.Sqrt(iPerfilX / area);

            moduloWx = iPerfilX / ycg;

            // Calculo do xo, cw, J
            // Momento em Y
            iPerfilY = (momentoby3 + areaB3 * Math.Pow(xb3, 2)) +
                       2 * (momentoby2 + areaB2 * Math.Pow(xB2, 2)) +
                       2 * (momentoby1 + areaB1 * Math.Pow(xb1, 2));

            ry = Math.Sqrt(iPerfilY / area);

            moduloWy = iPerfilY / xg;

            double am = b3m;
            double bm, cm = b1m;

            double bethaL, bethaF, bethaW;

            if (b1m == 0)
            {
                bethaL = 0;
                bm     = b2m;
                xo     = (Math.Pow(bm, 2) / (am + 2 * bm)) + (3 * Math.Pow(bm, 2)) / (6 * bm + am); //Wei-Wu pg. 385
                jx     = (Math.Pow(t, 3) * (am + 2 * bm)) / 3;
                cw     = ((t * Math.Pow(am, 2) * Math.Pow(bm, 3)) / 12) * ((3 * bm + 2 * am) / (6 * bm + am));
            }
            else
            {
                bm = b2m;
                // Wei Wu pg. 385
                xo = xg + bm * ((6 * Math.Pow(am, 2) * cm + 3 * bm * Math.Pow(am, 2) - 8 * Math.Pow(cm, 3)) /
                                (Math.Pow(am, 3) + 6 * bm * Math.Pow(am, 2) + 6 * cm * Math.Pow(am, 2)
                                 - 12 * am * Math.Pow(cm, 2) + 8 * Math.Pow(cm, 3)));

                jx = Math.Pow(t, 3) * (am + 2 * bm + 2 * cm) / 3;

                double Ix = t / 12 * (Math.Pow(am, 3) + 6 * bm * Math.Pow(am, 2) + 6 * cm * Math.Pow(am, 2)
                                      - 12 * am * Math.Pow(cm, 2) + 8 * Math.Pow(cm, 3));

                double m = bm * t / (12 * Ix) * (6 * cm * Math.Pow(am, 2) + 3 * bm * Math.Pow(am, 2) - 8 * Math.Pow(cm, 3));
                cw = Math.Pow(t, 2) / area * (xg * area * Math.Pow(am, 2) / t * (Math.Pow(bm, 2) / 3 + Math.Pow(m, 2) - m * bm) +
                                              area / (3 * t) * (Math.Pow(m, 2) * Math.Pow(am, 3) + Math.Pow(bm, 2) * Math.Pow(cm, 2) * (2 * cm + 3 * am)) -
                                              Ix * Math.Pow(m, 2) / t * (2 * am + 4 * cm) +
                                              m * Math.Pow(cm, 2) / 3 * (8 * Math.Pow(bm, 2) * cm + 2 * m * (2 * cm * (cm - am) + bm * (2 * cm - 3 * am))) +
                                              Math.Pow(bm, 2) * Math.Pow(am, 2) / 6 * ((3 * cm + bm) * (4 * cm + am) - 6 * Math.Pow(cm, 2)) -
                                              Math.Pow(m, 2) * Math.Pow(am, 4) / 4);

                bethaL = 2 * cm * t * Math.Pow(bm - xg, 3) + 2 / 3 * t * (bm - xg) * ((Math.Pow(am / 2, 3) - Math.Pow(am / 2 - cm, 3)));
            }

            bethaF = (t / 2) * (Math.Pow((bm - xg), 4) - Math.Pow(xg, 4)) + (t * Math.Pow(am, 2) / 4) * (Math.Pow((bm - xg), 2) - Math.Pow(xg, 2));
            bethaW = -(t * xg * Math.Pow(am, 3) / 12 + t * Math.Pow(xg, 3) * am);

            jy = 1 / (2 * iPerfilY) * (bethaW + bethaL + bethaF) + xo;
            ro = Math.Sqrt(Math.Pow(rx, 2) + Math.Pow(ry, 2) + Math.Pow(xo, 2));
        }
        public static List <double> // (area efetiva (0), modulo W x efetivo (1), modulo W efetivo Y (2))
        propEfetivasPerfilU(Perfil perfil, List <double> listaEfetivos, string solicitacao)
        {
            double t         = perfil.PegarEspessura();
            double raio      = perfil.PegarRaio();
            double elemento1 = perfil.PegarElemento1();
            double elemento2 = perfil.PegarElemento2();
            double elemento3 = perfil.PegarElemento3();
            double elemento5 = perfil.PegarElemento5();

            double yCGefetivo, deslYcg, xCGefetivo, deslXcg;
            double Iy = iPerfilY; //Inercia do Perfil em Y

            double b1ef = listaEfetivos.ElementAt(1); double b2ef = listaEfetivos.ElementAt(2); double b3ef = listaEfetivos.ElementAt(3);
            double b4ef = listaEfetivos.ElementAt(4); double b5ef = listaEfetivos.ElementAt(5); double ds = listaEfetivos.ElementAt(8);
            double b2ef2 = listaEfetivos.ElementAt(8); double b3ef2 = listaEfetivos.ElementAt(9);

            // A retirar de cada elemento
            double retB1 = b1 - b1ef;
            double retB2 = b2 - b2ef;
            double retB3 = b3 - b3ef - b3ef2;
            double retB4 = b4 - b4ef;
            double retB5 = b5 - b5ef;

            yCGefetivo = listaEfetivos.ElementAt(6);
            deslYcg    = Math.Abs(ycg - yCGefetivo);

            xCGefetivo = listaEfetivos.ElementAt(7);
            deslXcg    = xg - xCGefetivo;

            // Aera a retirar por elemento
            double areaRet1 = retB1 * t;
            double areaRet2 = retB2 * t;
            double areaRet3 = retB3 * t;
            double areaRet4 = retB4 * t;
            double areaRet5 = retB5 * t;
            double areaRetds; double retDs;

            if (b1 != 0)
            {
                retDs     = (b1 - ds);
                areaRetds = t * retDs;
            }
            else
            {
                retDs = 0; areaRetds = 0;
            }

            double areaRet     = (areaRet1 + areaRet2 + areaRet3 + areaRet4 + areaRet5 + areaRetds * 2);
            double areaEfetiva = area - areaRet;

            //==================================================================================
            // Inercia a retirar por elemento, em X
            // Enrijecedor - elemento 1
            double yCGb1        = Funcoes.novoCGelementos(yCGefetivo, t, b1, retB1);
            double inerciaRet1X = (t * Math.Pow(retB1, 3)) / 12 + areaRet1 * Math.Pow(yCGb1, 2);

            // Mesa - elemento 2
            double yCGb2        = (yCGefetivo - (t * 0.5));
            double inerciaRet2X = (retB2 * Math.Pow(t, 3)) / 12 + areaRet2 * Math.Pow(yCGb2, 2);

            // Alma - elemento 3
            double yCGb3;

            if (solicitacao == "COMPRESSAO")
            {
                yCGb3 = 0;
            }
            else // Flexao
            {
                yCGb3 = retB3 * 0.5;
            }
            double inerciaRet3X = (t * Math.Pow(retB3, 3)) / 12 + areaRet3 * Math.Pow(yCGb3, 2);

            // Mesa - elemento 4
            double yCGb4        = (yCGefetivo - (t * 0.5));
            double inerciaRet4X = (retB4 * Math.Pow(t, 3)) / 12 + areaRet4 * Math.Pow(yCGb4, 2);

            // Enrijecedor - elemento 5
            double yCGb5        = Funcoes.novoCGelementos(yCGefetivo, t, b5, retB5);
            double inerciaRet5X = (t * Math.Pow(retB5, 3)) / 12 + areaRet5 * Math.Pow(yCGb5, 2);

            // Enrijecedor - conforme Item 9.2.3.1 (Largura efetiva de elementos comprimidos com enrijecedor)
            double yCGds        = Funcoes.novoCGelementos(yCGefetivo, t, b1, retDs);
            double inerciaRetds = (t * Math.Pow(retDs, 3)) / 12 + areaRetds * Math.Pow(yCGds, 2);

            double inerciaRetTotal;

            if (solicitacao == "COMPRESSAO")
            { //retira-se duas vezes a não efetividade do enrijecedor, dado por ds
                inerciaRetTotal = inerciaRet1X + inerciaRet2X + inerciaRet3X + inerciaRet4X + inerciaRet5X + inerciaRetds * 2;
            }
            else // Flexao em X
            {//retira-se uma vez a não efetividade do enrijecedor, dado por ds
                inerciaRetTotal = inerciaRet1X + inerciaRet2X + inerciaRet3X + inerciaRet4X + inerciaRet5X + inerciaRetds;
            }

            double inerciaEfetivaX = iPerfilX - inerciaRetTotal + areaEfetiva * Math.Pow(deslYcg, 2);
            double moduloWXEfetivo = inerciaEfetivaX / yCGefetivo;
            //==================================================================================

            //Inercia a retirar por elemento, em Y
            //Mesa - elemento 2
            double retB2Y = b2 - (b2ef); //TODO ajustar o calculo da Wef, pois esta errado a definição do momento a retirar e Xcg
            double xCGb2;

            if (b1 == 0)
            {
                xCGb2 = b2 - retB2Y - xg;
            }
            else
            {
                xCGb2 = b2 * 0.5 - xg;
            }
            double areaRetB2y    = retB2Y * t;
            double inerciaRetB2Y = (t * Math.Pow(retB2Y, 3) / 12) + areaRetB2y * Math.Pow(xCGb2, 3);

            //Alma - elemento 3
            double retB3Y        = b3 - (b3ef + b3ef2);
            double xCGb3         = 0;
            double areaRetB3y    = retB3Y * t;
            double inerciaRetB3y = (retB3Y * Math.Pow(t, 3) / 12) + areaRetB3y * Math.Pow(xCGb3, 2);

            areaEfetiva     = area - areaRetB2y - areaRetB3y;
            inerciaRetTotal = inerciaRetB3y + inerciaRetB2Y;

            double inerciaEfetivaY = iPerfilY - inerciaRetTotal + areaEfetiva * Math.Pow(deslXcg, 2);
            double moduloWYEfetivo = inerciaEfetivaY / xCGefetivo;

            List <double> retorno = new List <double>();

            retorno.Add(areaEfetiva); retorno.Add(moduloWXEfetivo); retorno.Add(moduloWYEfetivo);
            return(retorno);
        }
        MLEPerfilUFlexaoX(Perfil perfil, double tensao)
        {
            double t         = perfil.PegarEspessura();
            double raio      = perfil.PegarRaio();
            double elemento1 = perfil.PegarElemento1();
            double elemento2 = perfil.PegarElemento2();
            double elemento3 = perfil.PegarElemento3();
            double elemento5 = perfil.PegarElemento5();

            // Obtenção das larguras efetivas dos elementos de Perfil U
            double ycgf = 0, contador = 3;
            double ycgi = ycg, areaRetirar;

            while (contador >= 2)
            {
                contador = 0;
                //Obtenção das Larguras efetivas de cada elemento, nas configurações de Perfil U

                // Enrijecedor
                if (b1 == 0)
                {
                    b1ef = 0;
                }
                else
                {
                    b1ef = NBR.MLECompleta("AL", "FLEXAOX", tensao, b1, t, raio, b1, ycgi).ElementAt(0);
                }
                if (b1 == b1ef)
                {
                    ycgf = ycgi;
                }
                else
                {
                    areaRetirar = t * ((b1 - b1ef));
                    double areaEfetiva = area - t * ((b1 - b1ef));
                    ycgf = ycgi + ((areaRetirar / areaEfetiva) * (ycg - t * 0.5)); contador += 1;
                }

                // Mesa, totalmente comprimida
                if (b1 == 0)
                { // Caso não tenha enrijecedor
                    b2ef         = NBR.MLECompleta("AL", "COMPRESSAO", tensao, b2, t, raio, b2, ycgf);
                    areaRetirar  = t * (b2 - b2ef.ElementAt(0));
                    areaEfetiva -= areaRetirar;
                }
                else
                { // Caso tenha enrijecedor
                    b2ef         = NBR.elementoEnrijecido(b2, elemento1, b1ef, tensao, t);
                    areaRetirar  = t * (b2 - b2ef.ElementAt(0) + b1 - b2ef.ElementAt(1));
                    areaEfetiva -= areaRetirar;
                }

                if (areaRetirar == 0)
                {
                }
                else
                {
                    ycgf += ((areaRetirar / areaEfetiva) * (ycg - t * 0.5)); contador += 1;
                }

                //Alma, parcialmente comprimida
                b3ef  = NBR.MLECompleta("AA", "FLEXAOX", tensao, b3, t, raio, b3, ycgf).ElementAt(0);
                b3ef2 = NBR.MLECompleta("AA", "FLEXAOX", tensao, b3, t, raio, b3, ycgf).ElementAt(1);
                if (b3 == b3ef + b3ef2)
                {
                }
                else
                {
                    areaRetirar  = t * (b3 - b3ef - b3ef2);
                    areaEfetiva -= areaRetirar;
                    ycgf        += Math.Round(((areaRetirar / areaEfetiva) * (ycg - t * 0.5)), 3); contador += 3;
                }

                if (contador >= 3) //Caso enrijecedor, mesa e alma não sejam totalmente efetivos;
                {
                    double b3efi = b3ef; double b3ef2i = b3ef2;

                    b3ef  = NBR.MLECompleta("AA", "FLEXAOX", tensao, b3, t, raio, b3, ycgf).ElementAt(0);
                    b3ef2 = NBR.MLECompleta("AA", "FLEXAOX", tensao, b3, t, raio, b3, ycgf).ElementAt(1);

                    areaRetirar  = t * (b3 - b3ef - b3ef2);
                    areaEfetiva -= areaRetirar;
                    ycgf        += Math.Round(((areaRetirar / areaEfetiva) * (ycg - t * 0.5)), 3);

                    double relacao = (b3efi + b3ef2i) / (b3ef + b3ef2); // Verifica se pode se desprezar a proxima iteração.
                    if (relacao < 0.95)
                    {
                        ycgi = ycgf; continue;
                    }
                    else
                    {
                        break;
                    }
                }
                ycgi = ycgf;
            }

            List <double> lstEfetivos = new List <double>();

            // (t, b1ef, b2ef, b3ef, b4ef, b5ef, b3ef2)
            lstEfetivos.Add(t);                 //0
            lstEfetivos.Add(b1ef);              //1, comprimid0
            lstEfetivos.Add(b2ef.ElementAt(0)); //2, comprimida
            lstEfetivos.Add(b3ef);              //3. parcialmente comprimido
            lstEfetivos.Add(b4);                //4, tracionado
            lstEfetivos.Add(b5);                //5, tracionado
            lstEfetivos.Add(ycgf);              //6
            lstEfetivos.Add(xg);                //7
            lstEfetivos.Add(b2ef.ElementAt(1)); //8, ds
            lstEfetivos.Add(b3ef2);             //9

            return(lstEfetivos);
        }
        MLEPerfilUFlexaoY(Perfil perfil, double tensao)
        {
            double t         = perfil.PegarEspessura();
            double raio      = perfil.PegarRaio();
            double elemento1 = perfil.PegarElemento1();
            double elemento2 = perfil.PegarElemento2();
            double elemento4 = perfil.PegarElemento4();
            double elemento3 = perfil.PegarElemento3();
            double elemento5 = perfil.PegarElemento5();

            double xgi, xgf = 0;
            double tensaoAt1 = 0, tensaoAt2 = tensao;

            xgi = xg;
            // Primeira Situaçao - Alma comprimida
            //Alma totalmente comprimida = elemento AA
            while (tensaoAt1 != tensaoAt2) // TODO corrigir loop infinito
            {
                tensaoAt1 = tensaoAt2;

                b3ef = NBR.MLECompleta("AA", "COMPRESSAO", tensaoAt1, b3, t, raio, b3, xg).ElementAt(0);
                if (b3ef != b3)
                {
                    double areaRetirar = (b3 - b3ef) * t;
                    xgf = xgi + areaRetirar / area * (xg - 0.5 * t);
                }
                else
                {
                    xgf = xgi;
                }

                tensaoAt2 = Math.Round(tensao * xgf / (b2 - xgf), 2);
                xgi       = xgf;
                if (xgf > elemento2)
                {
                    xgf = elemento2; b3ef = 0; break;
                }
            }

            //Verificação da Mesa, elemento parcialmente comprimido - AA
            double xgMesa;

            if (xgf > 0.5 * elemento2)
            {
                xgMesa = xgf;
            }
            else
            {
                xgMesa = elemento2 - xgf;
            }
            b2ef = NBR.MLECompleta("AA", "FLEXAOY", tensaoAt2, b2, t, raio, 0, xgMesa);

            List <double> lstEfetivos = new List <double>();

            // (t, b1ef, b2ef, b3ef, b4ef, b5ef, b3ef2)
            lstEfetivos.Add(t);                 //0
            lstEfetivos.Add(b1);                //1
            lstEfetivos.Add(b2ef.ElementAt(0)); //2
            lstEfetivos.Add(b3ef);              //3
            lstEfetivos.Add(b2ef.ElementAt(0)); //4, b4ef
            lstEfetivos.Add(b5);                //5
            lstEfetivos.Add(ycg);               //6
            lstEfetivos.Add(xgf);               //7
            lstEfetivos.Add(b2ef.ElementAt(1)); //8, ds
            lstEfetivos.Add(b3ef2);             //9
            lstEfetivos.Add(b2ef.ElementAt(1)); //10, bef2

            return(lstEfetivos);
        }
        MLEPerfilUCompressao(Perfil perfil, double tensao)
        {
            double t         = perfil.PegarEspessura();
            double raio      = perfil.PegarRaio();
            double elemento1 = perfil.PegarElemento1();
            double elemento2 = perfil.PegarElemento2();
            double elemento3 = perfil.PegarElemento3();
            double elemento5 = perfil.PegarElemento5();

            string solicitacao = "COMPRESSAO";

            //Obtenção das Larguras efetivas de cada elemento, nas configurações de Perfil U
            // Elementos totalmente comprimidos
            if (b1 <= 0)
            {
                b1ef = 0;
            }
            else
            {
                b1ef = NBR.MLECompleta("AL", solicitacao, tensao, b1, t, raio, 0, ycg).ElementAt(0);
            }

            if (b1 <= 0)
            {
                b2ef = NBR.MLECompleta("AL", solicitacao, tensao, b2, t, raio, 0, ycg);
            }
            else
            {
                b2ef = NBR.elementoEnrijecido(b2, elemento1, b1ef, tensao, t);
            }

            b3ef  = NBR.MLECompleta("AA", solicitacao, tensao, b3, t, raio, 0, ycg).ElementAt(0);
            b3ef2 = NBR.MLECompleta("AA", solicitacao, tensao, b3, t, raio, 0, ycg).ElementAt(1);

            if (b5 <= 0)
            {
                b5ef = 0;
            }
            else
            {
                b5ef = NBR.MLECompleta("AL", solicitacao, tensao, b5, t, raio, 0, ycg).ElementAt(0);
            }

            if (b5 <= 0)
            {
                b4ef = NBR.MLECompleta("AL", solicitacao, tensao, b4, t, raio, 0, ycg);
            }
            else
            {
                b4ef = NBR.elementoEnrijecido(b4, elemento5, b5ef, tensao, t);
            }

            List <double> listaEfetivos = new List <double>();

            // (t, b1ef, b2ef, b3ef, b4ef, b5ef, b3ef2)
            listaEfetivos.Add(t);                 //0
            listaEfetivos.Add(b1ef);              //1
            listaEfetivos.Add(b2ef.ElementAt(0)); //2
            listaEfetivos.Add(b3ef);              //3
            listaEfetivos.Add(b4ef.ElementAt(0)); //4
            listaEfetivos.Add(b5ef);              //5
            listaEfetivos.Add(ycg);               // 6, ycgEfetivo
            listaEfetivos.Add(xg);                //7
            listaEfetivos.Add(b2ef.ElementAt(1)); //8, ds
            listaEfetivos.Add(0);                 //9, b3ef2
            //  listaEfetivos.Add(Form1.xg);

            return(listaEfetivos);
            //return new Tuple<double, double, double, double, double, double>
            //   (espessura, b1ef, b2ef, b3ef, b4ef, b5ef, ycg, xg);
        }