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);
}